Pythia8 with HNLs
PythonWrapper.h
1 // Copyright (C) 2018 Torbjorn Sjostrand.
2 // PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
3 // Please respect the MCnet Guidelines, see GUIDELINES for details.
4 // Author: Philip Ilten, March 2016.
5 
6 // This file contains a Python interface to Pythia 8 generated with SWIG.
7 
8 /* ----------------------------------------------------------------------------
9  * This file was automatically generated by SWIG (http://www.swig.org).
10  * Version 3.0.8
11  *
12  * This file is not intended to be easily readable and contains a number of
13  * coding conventions designed to improve portability and efficiency. Do not make
14  * changes to this file unless you know what you are doing--modify the SWIG
15  * interface file instead.
16  * ----------------------------------------------------------------------------- */
17 
18 
19 #ifndef SWIGPYTHON
20 #define SWIGPYTHON
21 #endif
22 
23 #define SWIG_DIRECTORS
24 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
25 
26 
27 #ifdef __cplusplus
28 /* SwigValueWrapper is described in swig.swg */
29 template<typename T> class SwigValueWrapper {
30  struct SwigMovePointer {
31  T *ptr;
32  SwigMovePointer(T *p) : ptr(p) { }
33  ~SwigMovePointer() { delete ptr; }
34  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
35  } pointer;
36  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
37  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
38 public:
39  SwigValueWrapper() : pointer(0) { }
40  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
41  operator T&() const { return *pointer.ptr; }
42  T *operator&() { return pointer.ptr; }
43 };
44 
45 template <typename T> T SwigValueInit() {
46  return T();
47 }
48 #endif
49 
50 /* -----------------------------------------------------------------------------
51  * This section contains generic SWIG labels for method/variable
52  * declarations/attributes, and other compiler dependent labels.
53  * ----------------------------------------------------------------------------- */
54 
55 /* template workaround for compilers that cannot correctly implement the C++ standard */
56 #ifndef SWIGTEMPLATEDISAMBIGUATOR
57 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
58 # define SWIGTEMPLATEDISAMBIGUATOR template
59 # elif defined(__HP_aCC)
60 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
61 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
62 # define SWIGTEMPLATEDISAMBIGUATOR template
63 # else
64 # define SWIGTEMPLATEDISAMBIGUATOR
65 # endif
66 #endif
67 
68 /* inline attribute */
69 #ifndef SWIGINLINE
70 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
71 # define SWIGINLINE inline
72 # else
73 # define SWIGINLINE
74 # endif
75 #endif
76 
77 /* attribute recognised by some compilers to avoid 'unused' warnings */
78 #ifndef SWIGUNUSED
79 # if defined(__GNUC__)
80 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
81 # define SWIGUNUSED __attribute__ ((__unused__))
82 # else
83 # define SWIGUNUSED
84 # endif
85 # elif defined(__ICC)
86 # define SWIGUNUSED __attribute__ ((__unused__))
87 # else
88 # define SWIGUNUSED
89 # endif
90 #endif
91 
92 #ifndef SWIG_MSC_UNSUPPRESS_4505
93 # if defined(_MSC_VER)
94 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
95 # endif
96 #endif
97 
98 #ifndef SWIGUNUSEDPARM
99 # ifdef __cplusplus
100 # define SWIGUNUSEDPARM(p)
101 # else
102 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
103 # endif
104 #endif
105 
106 /* internal SWIG method */
107 #ifndef SWIGINTERN
108 # define SWIGINTERN static SWIGUNUSED
109 #endif
110 
111 /* internal inline SWIG method */
112 #ifndef SWIGINTERNINLINE
113 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
114 #endif
115 
116 /* exporting methods */
117 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
118 # ifndef GCC_HASCLASSVISIBILITY
119 # define GCC_HASCLASSVISIBILITY
120 # endif
121 #endif
122 
123 #ifndef SWIGEXPORT
124 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
125 # if defined(STATIC_LINKED)
126 # define SWIGEXPORT
127 # else
128 # define SWIGEXPORT __declspec(dllexport)
129 # endif
130 # else
131 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
132 # define SWIGEXPORT __attribute__ ((visibility("default")))
133 # else
134 # define SWIGEXPORT
135 # endif
136 # endif
137 #endif
138 
139 /* calling conventions for Windows */
140 #ifndef SWIGSTDCALL
141 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
142 # define SWIGSTDCALL __stdcall
143 # else
144 # define SWIGSTDCALL
145 # endif
146 #endif
147 
148 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
149 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
150 # define _CRT_SECURE_NO_DEPRECATE
151 #endif
152 
153 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
154 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
155 # define _SCL_SECURE_NO_DEPRECATE
156 #endif
157 
158 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
159 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
160 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
161 #endif
162 
163 /* Intel's compiler complains if a variable which was never initialised is
164  * cast to void, which is a common idiom which we use to indicate that we
165  * are aware a variable isn't used. So we just silence that warning.
166  * See: https://github.com/swig/swig/issues/192 for more discussion.
167  */
168 #ifdef __INTEL_COMPILER
169 # pragma warning disable 592
170 #endif
171 
172 
173 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
174 /* Use debug wrappers with the Python release dll */
175 # undef _DEBUG
176 # include <Python.h>
177 # define _DEBUG
178 #else
179 # include <Python.h>
180 #endif
181 
182 /* -----------------------------------------------------------------------------
183  * swigrun.swg
184  *
185  * This file contains generic C API SWIG runtime support for pointer
186  * type checking.
187  * ----------------------------------------------------------------------------- */
188 
189 /* This should only be incremented when either the layout of swig_type_info changes,
190  or for whatever reason, the runtime changes incompatibly */
191 #define SWIG_RUNTIME_VERSION "4"
192 
193 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
194 #ifdef SWIG_TYPE_TABLE
195 # define SWIG_QUOTE_STRING(x) #x
196 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
197 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
198 #else
199 # define SWIG_TYPE_TABLE_NAME
200 #endif
201 
202 /*
203  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
204  creating a static or dynamic library from the SWIG runtime code.
205  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
206 
207  But only do this if strictly necessary, ie, if you have problems
208  with your compiler or suchlike.
209 */
210 
211 #ifndef SWIGRUNTIME
212 # define SWIGRUNTIME SWIGINTERN
213 #endif
214 
215 #ifndef SWIGRUNTIMEINLINE
216 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
217 #endif
218 
219 /* Generic buffer size */
220 #ifndef SWIG_BUFFER_SIZE
221 # define SWIG_BUFFER_SIZE 1024
222 #endif
223 
224 /* Flags for pointer conversions */
225 #define SWIG_POINTER_DISOWN 0x1
226 #define SWIG_CAST_NEW_MEMORY 0x2
227 
228 /* Flags for new pointer objects */
229 #define SWIG_POINTER_OWN 0x1
230 
231 
232 /*
233  Flags/methods for returning states.
234 
235  The SWIG conversion methods, as ConvertPtr, return an integer
236  that tells if the conversion was successful or not. And if not,
237  an error code can be returned (see swigerrors.swg for the codes).
238 
239  Use the following macros/flags to set or process the returning
240  states.
241 
242  In old versions of SWIG, code such as the following was usually written:
243 
244  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
245  // success code
246  } else {
247  //fail code
248  }
249 
250  Now you can be more explicit:
251 
252  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
253  if (SWIG_IsOK(res)) {
254  // success code
255  } else {
256  // fail code
257  }
258 
259  which is the same really, but now you can also do
260 
261  Type *ptr;
262  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
263  if (SWIG_IsOK(res)) {
264  // success code
265  if (SWIG_IsNewObj(res) {
266  ...
267  delete *ptr;
268  } else {
269  ...
270  }
271  } else {
272  // fail code
273  }
274 
275  I.e., now SWIG_ConvertPtr can return new objects and you can
276  identify the case and take care of the deallocation. Of course that
277  also requires SWIG_ConvertPtr to return new result values, such as
278 
279  int SWIG_ConvertPtr(obj, ptr,...) {
280  if (<obj is ok>) {
281  if (<need new object>) {
282  *ptr = <ptr to new allocated object>;
283  return SWIG_NEWOBJ;
284  } else {
285  *ptr = <ptr to old object>;
286  return SWIG_OLDOBJ;
287  }
288  } else {
289  return SWIG_BADOBJ;
290  }
291  }
292 
293  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
294  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
295  SWIG errors code.
296 
297  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
298  allows to return the 'cast rank', for example, if you have this
299 
300  int food(double)
301  int fooi(int);
302 
303  and you call
304 
305  food(1) // cast rank '1' (1 -> 1.0)
306  fooi(1) // cast rank '0'
307 
308  just use the SWIG_AddCast()/SWIG_CheckState()
309 */
310 
311 #define SWIG_OK (0)
312 #define SWIG_ERROR (-1)
313 #define SWIG_IsOK(r) (r >= 0)
314 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
315 
316 /* The CastRankLimit says how many bits are used for the cast rank */
317 #define SWIG_CASTRANKLIMIT (1 << 8)
318 /* The NewMask denotes the object was created (using new/malloc) */
319 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
320 /* The TmpMask is for in/out typemaps that use temporal objects */
321 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
322 /* Simple returning values */
323 #define SWIG_BADOBJ (SWIG_ERROR)
324 #define SWIG_OLDOBJ (SWIG_OK)
325 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
326 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
327 /* Check, add and del mask methods */
328 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
329 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
330 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
331 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
332 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
333 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
334 
335 /* Cast-Rank Mode */
336 #if defined(SWIG_CASTRANK_MODE)
337 # ifndef SWIG_TypeRank
338 # define SWIG_TypeRank unsigned long
339 # endif
340 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
341 # define SWIG_MAXCASTRANK (2)
342 # endif
343 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
344 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
345 SWIGINTERNINLINE int SWIG_AddCast(int r) {
346  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
347 }
348 SWIGINTERNINLINE int SWIG_CheckState(int r) {
349  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
350 }
351 #else /* no cast-rank mode */
352 # define SWIG_AddCast(r) (r)
353 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
354 #endif
355 
356 
357 #include <string.h>
358 
359 #ifdef __cplusplus
360 extern "C" {
361 #endif
362 
363 typedef void *(*swig_converter_func)(void *, int *);
364 typedef struct swig_type_info *(*swig_dycast_func)(void **);
365 
366 /* Structure to store information on one type */
367 typedef struct swig_type_info {
368  const char *name; /* mangled name of this type */
369  const char *str; /* human readable name of this type */
370  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
371  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
372  void *clientdata; /* language specific type data */
373  int owndata; /* flag if the structure owns the clientdata */
375 
376 /* Structure to store a type and conversion function used for casting */
377 typedef struct swig_cast_info {
378  swig_type_info *type; /* pointer to type that is equivalent to this type */
379  swig_converter_func converter; /* function to cast the void pointers */
380  struct swig_cast_info *next; /* pointer to next cast in linked list */
381  struct swig_cast_info *prev; /* pointer to the previous cast */
383 
384 /* Structure used to store module information
385  * Each module generates one structure like this, and the runtime collects
386  * all of these structures and stores them in a circularly linked list.*/
387 typedef struct swig_module_info {
388  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
389  size_t size; /* Number of types in this module */
390  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
391  swig_type_info **type_initial; /* Array of initially generated type structures */
392  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
393  void *clientdata; /* Language specific module data */
395 
396 /*
397  Compare two type names skipping the space characters, therefore
398  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
399 
400  Return 0 when the two name types are equivalent, as in
401  strncmp, but skipping ' '.
402 */
403 SWIGRUNTIME int
404 SWIG_TypeNameComp(const char *f1, const char *l1,
405  const char *f2, const char *l2) {
406  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
407  while ((*f1 == ' ') && (f1 != l1)) ++f1;
408  while ((*f2 == ' ') && (f2 != l2)) ++f2;
409  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
410  }
411  return (int)((l1 - f1) - (l2 - f2));
412 }
413 
414 /*
415  Check type equivalence in a name list like <name1>|<name2>|...
416  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
417 */
418 SWIGRUNTIME int
419 SWIG_TypeCmp(const char *nb, const char *tb) {
420  int equiv = 1;
421  const char* te = tb + strlen(tb);
422  const char* ne = nb;
423  while (equiv != 0 && *ne) {
424  for (nb = ne; *ne; ++ne) {
425  if (*ne == '|') break;
426  }
427  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
428  if (*ne) ++ne;
429  }
430  return equiv;
431 }
432 
433 /*
434  Check type equivalence in a name list like <name1>|<name2>|...
435  Return 0 if not equal, 1 if equal
436 */
437 SWIGRUNTIME int
438 SWIG_TypeEquiv(const char *nb, const char *tb) {
439  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
440 }
441 
442 /*
443  Check the typename
444 */
445 SWIGRUNTIME swig_cast_info *
446 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
447  if (ty) {
448  swig_cast_info *iter = ty->cast;
449  while (iter) {
450  if (strcmp(iter->type->name, c) == 0) {
451  if (iter == ty->cast)
452  return iter;
453  /* Move iter to the top of the linked list */
454  iter->prev->next = iter->next;
455  if (iter->next)
456  iter->next->prev = iter->prev;
457  iter->next = ty->cast;
458  iter->prev = 0;
459  if (ty->cast) ty->cast->prev = iter;
460  ty->cast = iter;
461  return iter;
462  }
463  iter = iter->next;
464  }
465  }
466  return 0;
467 }
468 
469 /*
470  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
471 */
472 SWIGRUNTIME swig_cast_info *
473 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
474  if (ty) {
475  swig_cast_info *iter = ty->cast;
476  while (iter) {
477  if (iter->type == from) {
478  if (iter == ty->cast)
479  return iter;
480  /* Move iter to the top of the linked list */
481  iter->prev->next = iter->next;
482  if (iter->next)
483  iter->next->prev = iter->prev;
484  iter->next = ty->cast;
485  iter->prev = 0;
486  if (ty->cast) ty->cast->prev = iter;
487  ty->cast = iter;
488  return iter;
489  }
490  iter = iter->next;
491  }
492  }
493  return 0;
494 }
495 
496 /*
497  Cast a pointer up an inheritance hierarchy
498 */
499 SWIGRUNTIMEINLINE void *
500 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
501  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
502 }
503 
504 /*
505  Dynamic pointer casting. Down an inheritance hierarchy
506 */
507 SWIGRUNTIME swig_type_info *
508 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
509  swig_type_info *lastty = ty;
510  if (!ty || !ty->dcast) return ty;
511  while (ty && (ty->dcast)) {
512  ty = (*ty->dcast)(ptr);
513  if (ty) lastty = ty;
514  }
515  return lastty;
516 }
517 
518 /*
519  Return the name associated with this type
520 */
521 SWIGRUNTIMEINLINE const char *
522 SWIG_TypeName(const swig_type_info *ty) {
523  return ty->name;
524 }
525 
526 /*
527  Return the pretty name associated with this type,
528  that is an unmangled type name in a form presentable to the user.
529 */
530 SWIGRUNTIME const char *
531 SWIG_TypePrettyName(const swig_type_info *type) {
532  /* The "str" field contains the equivalent pretty names of the
533  type, separated by vertical-bar characters. We choose
534  to print the last name, as it is often (?) the most
535  specific. */
536  if (!type) return NULL;
537  if (type->str != NULL) {
538  const char *last_name = type->str;
539  const char *s;
540  for (s = type->str; *s; s++)
541  if (*s == '|') last_name = s+1;
542  return last_name;
543  }
544  else
545  return type->name;
546 }
547 
548 /*
549  Set the clientdata field for a type
550 */
551 SWIGRUNTIME void
552 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
553  swig_cast_info *cast = ti->cast;
554  /* if (ti->clientdata == clientdata) return; */
555  ti->clientdata = clientdata;
556 
557  while (cast) {
558  if (!cast->converter) {
559  swig_type_info *tc = cast->type;
560  if (!tc->clientdata) {
561  SWIG_TypeClientData(tc, clientdata);
562  }
563  }
564  cast = cast->next;
565  }
566 }
567 SWIGRUNTIME void
568 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
569  SWIG_TypeClientData(ti, clientdata);
570  ti->owndata = 1;
571 }
572 
573 /*
574  Search for a swig_type_info structure only by mangled name
575  Search is a O(log #types)
576 
577  We start searching at module start, and finish searching when start == end.
578  Note: if start == end at the beginning of the function, we go all the way around
579  the circular list.
580 */
581 SWIGRUNTIME swig_type_info *
582 SWIG_MangledTypeQueryModule(swig_module_info *start,
583  swig_module_info *end,
584  const char *name) {
585  swig_module_info *iter = start;
586  do {
587  if (iter->size) {
588  size_t l = 0;
589  size_t r = iter->size - 1;
590  do {
591  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
592  size_t i = (l + r) >> 1;
593  const char *iname = iter->types[i]->name;
594  if (iname) {
595  int compare = strcmp(name, iname);
596  if (compare == 0) {
597  return iter->types[i];
598  } else if (compare < 0) {
599  if (i) {
600  r = i - 1;
601  } else {
602  break;
603  }
604  } else if (compare > 0) {
605  l = i + 1;
606  }
607  } else {
608  break; /* should never happen */
609  }
610  } while (l <= r);
611  }
612  iter = iter->next;
613  } while (iter != end);
614  return 0;
615 }
616 
617 /*
618  Search for a swig_type_info structure for either a mangled name or a human readable name.
619  It first searches the mangled names of the types, which is a O(log #types)
620  If a type is not found it then searches the human readable names, which is O(#types).
621 
622  We start searching at module start, and finish searching when start == end.
623  Note: if start == end at the beginning of the function, we go all the way around
624  the circular list.
625 */
626 SWIGRUNTIME swig_type_info *
627 SWIG_TypeQueryModule(swig_module_info *start,
628  swig_module_info *end,
629  const char *name) {
630  /* STEP 1: Search the name field using binary search */
631  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
632  if (ret) {
633  return ret;
634  } else {
635  /* STEP 2: If the type hasn't been found, do a complete search
636  of the str field (the human readable name) */
637  swig_module_info *iter = start;
638  do {
639  size_t i = 0;
640  for (; i < iter->size; ++i) {
641  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
642  return iter->types[i];
643  }
644  iter = iter->next;
645  } while (iter != end);
646  }
647 
648  /* neither found a match */
649  return 0;
650 }
651 
652 /*
653  Pack binary data into a string
654 */
655 SWIGRUNTIME char *
656 SWIG_PackData(char *c, void *ptr, size_t sz) {
657  static const char hex[17] = "0123456789abcdef";
658  const unsigned char *u = (unsigned char *) ptr;
659  const unsigned char *eu = u + sz;
660  for (; u != eu; ++u) {
661  unsigned char uu = *u;
662  *(c++) = hex[(uu & 0xf0) >> 4];
663  *(c++) = hex[uu & 0xf];
664  }
665  return c;
666 }
667 
668 /*
669  Unpack binary data from a string
670 */
671 SWIGRUNTIME const char *
672 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
673  unsigned char *u = (unsigned char *) ptr;
674  const unsigned char *eu = u + sz;
675  for (; u != eu; ++u) {
676  char d = *(c++);
677  unsigned char uu;
678  if ((d >= '0') && (d <= '9'))
679  uu = ((d - '0') << 4);
680  else if ((d >= 'a') && (d <= 'f'))
681  uu = ((d - ('a'-10)) << 4);
682  else
683  return (char *) 0;
684  d = *(c++);
685  if ((d >= '0') && (d <= '9'))
686  uu |= (d - '0');
687  else if ((d >= 'a') && (d <= 'f'))
688  uu |= (d - ('a'-10));
689  else
690  return (char *) 0;
691  *u = uu;
692  }
693  return c;
694 }
695 
696 /*
697  Pack 'void *' into a string buffer.
698 */
699 SWIGRUNTIME char *
700 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
701  char *r = buff;
702  if ((2*sizeof(void *) + 2) > bsz) return 0;
703  *(r++) = '_';
704  r = SWIG_PackData(r,&ptr,sizeof(void *));
705  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
706  strcpy(r,name);
707  return buff;
708 }
709 
710 SWIGRUNTIME const char *
711 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
712  if (*c != '_') {
713  if (strcmp(c,"NULL") == 0) {
714  *ptr = (void *) 0;
715  return name;
716  } else {
717  return 0;
718  }
719  }
720  return SWIG_UnpackData(++c,ptr,sizeof(void *));
721 }
722 
723 SWIGRUNTIME char *
724 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
725  char *r = buff;
726  size_t lname = (name ? strlen(name) : 0);
727  if ((2*sz + 2 + lname) > bsz) return 0;
728  *(r++) = '_';
729  r = SWIG_PackData(r,ptr,sz);
730  if (lname) {
731  strncpy(r,name,lname+1);
732  } else {
733  *r = 0;
734  }
735  return buff;
736 }
737 
738 SWIGRUNTIME const char *
739 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
740  if (*c != '_') {
741  if (strcmp(c,"NULL") == 0) {
742  memset(ptr,0,sz);
743  return name;
744  } else {
745  return 0;
746  }
747  }
748  return SWIG_UnpackData(++c,ptr,sz);
749 }
750 
751 #ifdef __cplusplus
752 }
753 #endif
754 
755 /* Errors in SWIG */
756 #define SWIG_UnknownError -1
757 #define SWIG_IOError -2
758 #define SWIG_RuntimeError -3
759 #define SWIG_IndexError -4
760 #define SWIG_TypeError -5
761 #define SWIG_DivisionByZero -6
762 #define SWIG_OverflowError -7
763 #define SWIG_SyntaxError -8
764 #define SWIG_ValueError -9
765 #define SWIG_SystemError -10
766 #define SWIG_AttributeError -11
767 #define SWIG_MemoryError -12
768 #define SWIG_NullReferenceError -13
769 
770 
771 
772 /* Compatibility macros for Python 3 */
773 #if PY_VERSION_HEX >= 0x03000000
774 
775 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
776 #define PyInt_Check(x) PyLong_Check(x)
777 #define PyInt_AsLong(x) PyLong_AsLong(x)
778 #define PyInt_FromLong(x) PyLong_FromLong(x)
779 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
780 #define PyString_Check(name) PyBytes_Check(name)
781 #define PyString_FromString(x) PyUnicode_FromString(x)
782 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
783 #define PyString_AsString(str) PyBytes_AsString(str)
784 #define PyString_Size(str) PyBytes_Size(str)
785 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
786 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
787 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
788 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
789 
790 #endif
791 
792 #ifndef Py_TYPE
793 # define Py_TYPE(op) ((op)->ob_type)
794 #endif
795 
796 /* SWIG APIs for compatibility of both Python 2 & 3 */
797 
798 #if PY_VERSION_HEX >= 0x03000000
799 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
800 #else
801 # define SWIG_Python_str_FromFormat PyString_FromFormat
802 #endif
803 
804 
805 /* Warning: This function will allocate a new string in Python 3,
806  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
807  */
808 SWIGINTERN char*
809 SWIG_Python_str_AsChar(PyObject *str)
810 {
811 #if PY_VERSION_HEX >= 0x03000000
812  char *cstr;
813  char *newstr;
814  Py_ssize_t len;
815  str = PyUnicode_AsUTF8String(str);
816  PyBytes_AsStringAndSize(str, &cstr, &len);
817  newstr = (char *) malloc(len+1);
818  memcpy(newstr, cstr, len+1);
819  Py_XDECREF(str);
820  return newstr;
821 #else
822  return PyString_AsString(str);
823 #endif
824 }
825 
826 #if PY_VERSION_HEX >= 0x03000000
827 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
828 #else
829 # define SWIG_Python_str_DelForPy3(x)
830 #endif
831 
832 
833 SWIGINTERN PyObject*
834 SWIG_Python_str_FromChar(const char *c)
835 {
836 #if PY_VERSION_HEX >= 0x03000000
837  return PyUnicode_FromString(c);
838 #else
839  return PyString_FromString(c);
840 #endif
841 }
842 
843 /* Add PyOS_snprintf for old Pythons */
844 #if PY_VERSION_HEX < 0x02020000
845 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
846 # define PyOS_snprintf _snprintf
847 # else
848 # define PyOS_snprintf snprintf
849 # endif
850 #endif
851 
852 /* A crude PyString_FromFormat implementation for old Pythons */
853 #if PY_VERSION_HEX < 0x02020000
854 
855 #ifndef SWIG_PYBUFFER_SIZE
856 # define SWIG_PYBUFFER_SIZE 1024
857 #endif
858 
859 static PyObject *
860 PyString_FromFormat(const char *fmt, ...) {
861  va_list ap;
862  char buf[SWIG_PYBUFFER_SIZE * 2];
863  int res;
864  va_start(ap, fmt);
865  res = vsnprintf(buf, sizeof(buf), fmt, ap);
866  va_end(ap);
867  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
868 }
869 #endif
870 
871 /* Add PyObject_Del for old Pythons */
872 #if PY_VERSION_HEX < 0x01060000
873 # define PyObject_Del(op) PyMem_DEL((op))
874 #endif
875 #ifndef PyObject_DEL
876 # define PyObject_DEL PyObject_Del
877 #endif
878 
879 /* A crude PyExc_StopIteration exception for old Pythons */
880 #if PY_VERSION_HEX < 0x02020000
881 # ifndef PyExc_StopIteration
882 # define PyExc_StopIteration PyExc_RuntimeError
883 # endif
884 # ifndef PyObject_GenericGetAttr
885 # define PyObject_GenericGetAttr 0
886 # endif
887 #endif
888 
889 /* Py_NotImplemented is defined in 2.1 and up. */
890 #if PY_VERSION_HEX < 0x02010000
891 # ifndef Py_NotImplemented
892 # define Py_NotImplemented PyExc_RuntimeError
893 # endif
894 #endif
895 
896 /* A crude PyString_AsStringAndSize implementation for old Pythons */
897 #if PY_VERSION_HEX < 0x02010000
898 # ifndef PyString_AsStringAndSize
899 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
900 # endif
901 #endif
902 
903 /* PySequence_Size for old Pythons */
904 #if PY_VERSION_HEX < 0x02000000
905 # ifndef PySequence_Size
906 # define PySequence_Size PySequence_Length
907 # endif
908 #endif
909 
910 /* PyBool_FromLong for old Pythons */
911 #if PY_VERSION_HEX < 0x02030000
912 static
913 PyObject *PyBool_FromLong(long ok)
914 {
915  PyObject *result = ok ? Py_True : Py_False;
916  Py_INCREF(result);
917  return result;
918 }
919 #endif
920 
921 /* Py_ssize_t for old Pythons */
922 /* This code is as recommended by: */
923 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
924 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
925 typedef int Py_ssize_t;
926 # define PY_SSIZE_T_MAX INT_MAX
927 # define PY_SSIZE_T_MIN INT_MIN
928 typedef inquiry lenfunc;
929 typedef intargfunc ssizeargfunc;
930 typedef intintargfunc ssizessizeargfunc;
931 typedef intobjargproc ssizeobjargproc;
932 typedef intintobjargproc ssizessizeobjargproc;
933 typedef getreadbufferproc readbufferproc;
934 typedef getwritebufferproc writebufferproc;
935 typedef getsegcountproc segcountproc;
936 typedef getcharbufferproc charbufferproc;
937 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
938 {
939  long result = 0;
940  PyObject *i = PyNumber_Int(x);
941  if (i) {
942  result = PyInt_AsLong(i);
943  Py_DECREF(i);
944  }
945  return result;
946 }
947 #endif
948 
949 #if PY_VERSION_HEX < 0x02050000
950 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
951 #endif
952 
953 #if PY_VERSION_HEX < 0x02040000
954 #define Py_VISIT(op) \
955  do { \
956  if (op) { \
957  int vret = visit((op), arg); \
958  if (vret) \
959  return vret; \
960  } \
961  } while (0)
962 #endif
963 
964 #if PY_VERSION_HEX < 0x02030000
965 typedef struct {
966  PyTypeObject type;
967  PyNumberMethods as_number;
968  PyMappingMethods as_mapping;
969  PySequenceMethods as_sequence;
970  PyBufferProcs as_buffer;
971  PyObject *name, *slots;
973 #endif
974 
975 #if PY_VERSION_HEX < 0x02030000
976 typedef destructor freefunc;
977 #endif
978 
979 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
980  (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
981  (PY_MAJOR_VERSION > 3))
982 # define SWIGPY_USE_CAPSULE
983 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
984 #endif
985 
986 #if PY_VERSION_HEX < 0x03020000
987 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
988 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
989 #endif
990 
991 /* -----------------------------------------------------------------------------
992  * error manipulation
993  * ----------------------------------------------------------------------------- */
994 
995 SWIGRUNTIME PyObject*
996 SWIG_Python_ErrorType(int code) {
997  PyObject* type = 0;
998  switch(code) {
999  case SWIG_MemoryError:
1000  type = PyExc_MemoryError;
1001  break;
1002  case SWIG_IOError:
1003  type = PyExc_IOError;
1004  break;
1005  case SWIG_RuntimeError:
1006  type = PyExc_RuntimeError;
1007  break;
1008  case SWIG_IndexError:
1009  type = PyExc_IndexError;
1010  break;
1011  case SWIG_TypeError:
1012  type = PyExc_TypeError;
1013  break;
1014  case SWIG_DivisionByZero:
1015  type = PyExc_ZeroDivisionError;
1016  break;
1017  case SWIG_OverflowError:
1018  type = PyExc_OverflowError;
1019  break;
1020  case SWIG_SyntaxError:
1021  type = PyExc_SyntaxError;
1022  break;
1023  case SWIG_ValueError:
1024  type = PyExc_ValueError;
1025  break;
1026  case SWIG_SystemError:
1027  type = PyExc_SystemError;
1028  break;
1029  case SWIG_AttributeError:
1030  type = PyExc_AttributeError;
1031  break;
1032  default:
1033  type = PyExc_RuntimeError;
1034  }
1035  return type;
1036 }
1037 
1038 
1039 SWIGRUNTIME void
1040 SWIG_Python_AddErrorMsg(const char* mesg)
1041 {
1042  PyObject *type = 0;
1043  PyObject *value = 0;
1044  PyObject *traceback = 0;
1045 
1046  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1047  if (value) {
1048  char *tmp;
1049  PyObject *old_str = PyObject_Str(value);
1050  PyErr_Clear();
1051  Py_XINCREF(type);
1052 
1053  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1054  SWIG_Python_str_DelForPy3(tmp);
1055  Py_DECREF(old_str);
1056  Py_DECREF(value);
1057  } else {
1058  PyErr_SetString(PyExc_RuntimeError, mesg);
1059  }
1060 }
1061 
1062 #if defined(SWIG_PYTHON_NO_THREADS)
1063 # if defined(SWIG_PYTHON_THREADS)
1064 # undef SWIG_PYTHON_THREADS
1065 # endif
1066 #endif
1067 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1068 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1069 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1070 # define SWIG_PYTHON_USE_GIL
1071 # endif
1072 # endif
1073 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1074 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1075 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1076 # endif
1077 # ifdef __cplusplus /* C++ code */
1078  class SWIG_Python_Thread_Block {
1079  bool status;
1080  PyGILState_STATE state;
1081  public:
1082  void end() { if (status) { PyGILState_Release(state); status = false;} }
1083  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1084  ~SWIG_Python_Thread_Block() { end(); }
1085  };
1086  class SWIG_Python_Thread_Allow {
1087  bool status;
1088  PyThreadState *save;
1089  public:
1090  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1091  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1092  ~SWIG_Python_Thread_Allow() { end(); }
1093  };
1094 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1095 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1096 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1097 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1098 # else /* C code */
1099 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1100 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1101 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1102 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1103 # endif
1104 # else /* Old thread way, not implemented, user must provide it */
1105 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1106 # define SWIG_PYTHON_INITIALIZE_THREADS
1107 # endif
1108 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1109 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1110 # endif
1111 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1112 # define SWIG_PYTHON_THREAD_END_BLOCK
1113 # endif
1114 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1115 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1116 # endif
1117 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1118 # define SWIG_PYTHON_THREAD_END_ALLOW
1119 # endif
1120 # endif
1121 #else /* No thread support */
1122 # define SWIG_PYTHON_INITIALIZE_THREADS
1123 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1124 # define SWIG_PYTHON_THREAD_END_BLOCK
1125 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1126 # define SWIG_PYTHON_THREAD_END_ALLOW
1127 #endif
1128 
1129 /* -----------------------------------------------------------------------------
1130  * Python API portion that goes into the runtime
1131  * ----------------------------------------------------------------------------- */
1132 
1133 #ifdef __cplusplus
1134 extern "C" {
1135 #endif
1136 
1137 /* -----------------------------------------------------------------------------
1138  * Constant declarations
1139  * ----------------------------------------------------------------------------- */
1140 
1141 /* Constant Types */
1142 #define SWIG_PY_POINTER 4
1143 #define SWIG_PY_BINARY 5
1144 
1145 /* Constant information structure */
1146 typedef struct swig_const_info {
1147  int type;
1148  char *name;
1149  long lvalue;
1150  double dvalue;
1151  void *pvalue;
1152  swig_type_info **ptype;
1153 } swig_const_info;
1154 
1155 
1156 /* -----------------------------------------------------------------------------
1157  * Wrapper of PyInstanceMethod_New() used in Python 3
1158  * It is exported to the generated module, used for -fastproxy
1159  * ----------------------------------------------------------------------------- */
1160 #if PY_VERSION_HEX >= 0x03000000
1161 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1162 {
1163  return PyInstanceMethod_New(func);
1164 }
1165 #else
1166 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1167 {
1168  return NULL;
1169 }
1170 #endif
1171 
1172 #ifdef __cplusplus
1173 }
1174 #endif
1175 
1176 
1177 /* -----------------------------------------------------------------------------
1178  * pyrun.swg
1179  *
1180  * This file contains the runtime support for Python modules
1181  * and includes code for managing global variables and pointer
1182  * type checking.
1183  *
1184  * ----------------------------------------------------------------------------- */
1185 
1186 /* Common SWIG API */
1187 
1188 /* for raw pointers */
1189 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1190 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1191 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1192 
1193 #ifdef SWIGPYTHON_BUILTIN
1194 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1195 #else
1196 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1197 #endif
1198 
1199 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1200 
1201 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1202 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1203 #define swig_owntype int
1204 
1205 /* for raw packed data */
1206 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1207 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1208 
1209 /* for class or struct pointers */
1210 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1211 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1212 
1213 /* for C or C++ function pointers */
1214 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1215 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1216 
1217 /* for C++ member pointers, ie, member methods */
1218 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1219 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1220 
1221 
1222 /* Runtime API */
1223 
1224 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1225 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1226 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1227 
1228 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1229 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1230 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1231 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1232 #define SWIG_fail goto fail
1233 
1234 
1235 /* Runtime API implementation */
1236 
1237 /* Error manipulation */
1238 
1239 SWIGINTERN void
1240 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1241  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1242  PyErr_SetObject(errtype, obj);
1243  Py_DECREF(obj);
1244  SWIG_PYTHON_THREAD_END_BLOCK;
1245 }
1246 
1247 SWIGINTERN void
1248 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1249  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1250  PyErr_SetString(errtype, msg);
1251  SWIG_PYTHON_THREAD_END_BLOCK;
1252 }
1253 
1254 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1255 
1256 /* Set a constant value */
1257 
1258 #if defined(SWIGPYTHON_BUILTIN)
1259 
1260 SWIGINTERN void
1261 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1262  PyObject *s = PyString_InternFromString(key);
1263  PyList_Append(seq, s);
1264  Py_DECREF(s);
1265 }
1266 
1267 SWIGINTERN void
1268 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1269 #if PY_VERSION_HEX < 0x02030000
1270  PyDict_SetItemString(d, (char *)name, obj);
1271 #else
1272  PyDict_SetItemString(d, name, obj);
1273 #endif
1274  Py_DECREF(obj);
1275  if (public_interface)
1276  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1277 }
1278 
1279 #else
1280 
1281 SWIGINTERN void
1282 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1283 #if PY_VERSION_HEX < 0x02030000
1284  PyDict_SetItemString(d, (char *)name, obj);
1285 #else
1286  PyDict_SetItemString(d, name, obj);
1287 #endif
1288  Py_DECREF(obj);
1289 }
1290 
1291 #endif
1292 
1293 /* Append a value to the result obj */
1294 
1295 SWIGINTERN PyObject*
1296 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1297 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1298  if (!result) {
1299  result = obj;
1300  } else if (result == Py_None) {
1301  Py_DECREF(result);
1302  result = obj;
1303  } else {
1304  if (!PyList_Check(result)) {
1305  PyObject *o2 = result;
1306  result = PyList_New(1);
1307  PyList_SetItem(result, 0, o2);
1308  }
1309  PyList_Append(result,obj);
1310  Py_DECREF(obj);
1311  }
1312  return result;
1313 #else
1314  PyObject* o2;
1315  PyObject* o3;
1316  if (!result) {
1317  result = obj;
1318  } else if (result == Py_None) {
1319  Py_DECREF(result);
1320  result = obj;
1321  } else {
1322  if (!PyTuple_Check(result)) {
1323  o2 = result;
1324  result = PyTuple_New(1);
1325  PyTuple_SET_ITEM(result, 0, o2);
1326  }
1327  o3 = PyTuple_New(1);
1328  PyTuple_SET_ITEM(o3, 0, obj);
1329  o2 = result;
1330  result = PySequence_Concat(o2, o3);
1331  Py_DECREF(o2);
1332  Py_DECREF(o3);
1333  }
1334  return result;
1335 #endif
1336 }
1337 
1338 /* Unpack the argument tuple */
1339 
1340 SWIGINTERN Py_ssize_t
1341 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1342 {
1343  if (!args) {
1344  if (!min && !max) {
1345  return 1;
1346  } else {
1347  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1348  name, (min == max ? "" : "at least "), (int)min);
1349  return 0;
1350  }
1351  }
1352  if (!PyTuple_Check(args)) {
1353  if (min <= 1 && max >= 1) {
1354  Py_ssize_t i;
1355  objs[0] = args;
1356  for (i = 1; i < max; ++i) {
1357  objs[i] = 0;
1358  }
1359  return 2;
1360  }
1361  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1362  return 0;
1363  } else {
1364  Py_ssize_t l = PyTuple_GET_SIZE(args);
1365  if (l < min) {
1366  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1367  name, (min == max ? "" : "at least "), (int)min, (int)l);
1368  return 0;
1369  } else if (l > max) {
1370  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1371  name, (min == max ? "" : "at most "), (int)max, (int)l);
1372  return 0;
1373  } else {
1374  Py_ssize_t i;
1375  for (i = 0; i < l; ++i) {
1376  objs[i] = PyTuple_GET_ITEM(args, i);
1377  }
1378  for (; l < max; ++l) {
1379  objs[l] = 0;
1380  }
1381  return i + 1;
1382  }
1383  }
1384 }
1385 
1386 /* A functor is a function object with one single object argument */
1387 #if PY_VERSION_HEX >= 0x02020000
1388 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1389 #else
1390 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1391 #endif
1392 
1393 /*
1394  Helper for static pointer initialization for both C and C++ code, for example
1395  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1396 */
1397 #ifdef __cplusplus
1398 #define SWIG_STATIC_POINTER(var) var
1399 #else
1400 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1401 #endif
1402 
1403 /* -----------------------------------------------------------------------------
1404  * Pointer declarations
1405  * ----------------------------------------------------------------------------- */
1406 
1407 /* Flags for new pointer objects */
1408 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1409 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1410 
1411 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1412 
1413 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1414 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1415 
1416 #ifdef __cplusplus
1417 extern "C" {
1418 #endif
1419 
1420 /* How to access Py_None */
1421 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1422 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1423 # ifndef SWIG_PYTHON_BUILD_NONE
1424 # define SWIG_PYTHON_BUILD_NONE
1425 # endif
1426 # endif
1427 #endif
1428 
1429 #ifdef SWIG_PYTHON_BUILD_NONE
1430 # ifdef Py_None
1431 # undef Py_None
1432 # define Py_None SWIG_Py_None()
1433 # endif
1434 SWIGRUNTIMEINLINE PyObject *
1435 _SWIG_Py_None(void)
1436 {
1437  PyObject *none = Py_BuildValue((char*)"");
1438  Py_DECREF(none);
1439  return none;
1440 }
1441 SWIGRUNTIME PyObject *
1442 SWIG_Py_None(void)
1443 {
1444  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1445  return none;
1446 }
1447 #endif
1448 
1449 /* The python void return value */
1450 
1451 SWIGRUNTIMEINLINE PyObject *
1452 SWIG_Py_Void(void)
1453 {
1454  PyObject *none = Py_None;
1455  Py_INCREF(none);
1456  return none;
1457 }
1458 
1459 /* SwigPyClientData */
1460 
1461 typedef struct {
1462  PyObject *klass;
1463  PyObject *newraw;
1464  PyObject *newargs;
1465  PyObject *destroy;
1466  int delargs;
1467  int implicitconv;
1468  PyTypeObject *pytype;
1470 
1471 SWIGRUNTIMEINLINE int
1472 SWIG_Python_CheckImplicit(swig_type_info *ty)
1473 {
1474  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1475  return data ? data->implicitconv : 0;
1476 }
1477 
1478 SWIGRUNTIMEINLINE PyObject *
1479 SWIG_Python_ExceptionType(swig_type_info *desc) {
1480  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1481  PyObject *klass = data ? data->klass : 0;
1482  return (klass ? klass : PyExc_RuntimeError);
1483 }
1484 
1485 
1486 SWIGRUNTIME SwigPyClientData *
1487 SwigPyClientData_New(PyObject* obj)
1488 {
1489  if (!obj) {
1490  return 0;
1491  } else {
1492  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1493  /* the klass element */
1494  data->klass = obj;
1495  Py_INCREF(data->klass);
1496  /* the newraw method and newargs arguments used to create a new raw instance */
1497  if (PyClass_Check(obj)) {
1498  data->newraw = 0;
1499  data->newargs = obj;
1500  Py_INCREF(obj);
1501  } else {
1502 #if (PY_VERSION_HEX < 0x02020000)
1503  data->newraw = 0;
1504 #else
1505  data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1506 #endif
1507  if (data->newraw) {
1508  Py_INCREF(data->newraw);
1509  data->newargs = PyTuple_New(1);
1510  PyTuple_SetItem(data->newargs, 0, obj);
1511  } else {
1512  data->newargs = obj;
1513  }
1514  Py_INCREF(data->newargs);
1515  }
1516  /* the destroy method, aka as the C++ delete method */
1517  data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1518  if (PyErr_Occurred()) {
1519  PyErr_Clear();
1520  data->destroy = 0;
1521  }
1522  if (data->destroy) {
1523  int flags;
1524  Py_INCREF(data->destroy);
1525  flags = PyCFunction_GET_FLAGS(data->destroy);
1526 #ifdef METH_O
1527  data->delargs = !(flags & (METH_O));
1528 #else
1529  data->delargs = 0;
1530 #endif
1531  } else {
1532  data->delargs = 0;
1533  }
1534  data->implicitconv = 0;
1535  data->pytype = 0;
1536  return data;
1537  }
1538 }
1539 
1540 SWIGRUNTIME void
1541 SwigPyClientData_Del(SwigPyClientData *data) {
1542  Py_XDECREF(data->newraw);
1543  Py_XDECREF(data->newargs);
1544  Py_XDECREF(data->destroy);
1545 }
1546 
1547 /* =============== SwigPyObject =====================*/
1548 
1549 typedef struct {
1550  PyObject_HEAD
1551  void *ptr;
1552  swig_type_info *ty;
1553  int own;
1554  PyObject *next;
1555 #ifdef SWIGPYTHON_BUILTIN
1556  PyObject *dict;
1557 #endif
1558 } SwigPyObject;
1559 
1560 
1561 #ifdef SWIGPYTHON_BUILTIN
1562 
1563 SWIGRUNTIME PyObject *
1564 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1565 {
1566  SwigPyObject *sobj = (SwigPyObject *)v;
1567 
1568  if (!sobj->dict)
1569  sobj->dict = PyDict_New();
1570 
1571  Py_INCREF(sobj->dict);
1572  return sobj->dict;
1573 }
1574 
1575 #endif
1576 
1577 SWIGRUNTIME PyObject *
1578 SwigPyObject_long(SwigPyObject *v)
1579 {
1580  return PyLong_FromVoidPtr(v->ptr);
1581 }
1582 
1583 SWIGRUNTIME PyObject *
1584 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1585 {
1586  PyObject *res = NULL;
1587  PyObject *args = PyTuple_New(1);
1588  if (args) {
1589  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1590  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1591  if (ofmt) {
1592 #if PY_VERSION_HEX >= 0x03000000
1593  res = PyUnicode_Format(ofmt,args);
1594 #else
1595  res = PyString_Format(ofmt,args);
1596 #endif
1597  Py_DECREF(ofmt);
1598  }
1599  Py_DECREF(args);
1600  }
1601  }
1602  return res;
1603 }
1604 
1605 SWIGRUNTIME PyObject *
1606 SwigPyObject_oct(SwigPyObject *v)
1607 {
1608  return SwigPyObject_format("%o",v);
1609 }
1610 
1611 SWIGRUNTIME PyObject *
1612 SwigPyObject_hex(SwigPyObject *v)
1613 {
1614  return SwigPyObject_format("%x",v);
1615 }
1616 
1617 SWIGRUNTIME PyObject *
1618 #ifdef METH_NOARGS
1619 SwigPyObject_repr(SwigPyObject *v)
1620 #else
1621 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1622 #endif
1623 {
1624  const char *name = SWIG_TypePrettyName(v->ty);
1625  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1626  if (v->next) {
1627 # ifdef METH_NOARGS
1628  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1629 # else
1630  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1631 # endif
1632 # if PY_VERSION_HEX >= 0x03000000
1633  PyObject *joined = PyUnicode_Concat(repr, nrep);
1634  Py_DecRef(repr);
1635  Py_DecRef(nrep);
1636  repr = joined;
1637 # else
1638  PyString_ConcatAndDel(&repr,nrep);
1639 # endif
1640  }
1641  return repr;
1642 }
1643 
1644 SWIGRUNTIME int
1645 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1646 {
1647  void *i = v->ptr;
1648  void *j = w->ptr;
1649  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1650 }
1651 
1652 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1653 SWIGRUNTIME PyObject*
1654 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1655 {
1656  PyObject* res;
1657  if( op != Py_EQ && op != Py_NE ) {
1658  Py_INCREF(Py_NotImplemented);
1659  return Py_NotImplemented;
1660  }
1661  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1662  return res;
1663 }
1664 
1665 
1666 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1667 
1668 #ifdef SWIGPYTHON_BUILTIN
1669 static swig_type_info *SwigPyObject_stype = 0;
1670 SWIGRUNTIME PyTypeObject*
1671 SwigPyObject_type(void) {
1672  SwigPyClientData *cd;
1673  assert(SwigPyObject_stype);
1674  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1675  assert(cd);
1676  assert(cd->pytype);
1677  return cd->pytype;
1678 }
1679 #else
1680 SWIGRUNTIME PyTypeObject*
1681 SwigPyObject_type(void) {
1682  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1683  return type;
1684 }
1685 #endif
1686 
1687 SWIGRUNTIMEINLINE int
1688 SwigPyObject_Check(PyObject *op) {
1689 #ifdef SWIGPYTHON_BUILTIN
1690  PyTypeObject *target_tp = SwigPyObject_type();
1691  if (PyType_IsSubtype(op->ob_type, target_tp))
1692  return 1;
1693  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1694 #else
1695  return (Py_TYPE(op) == SwigPyObject_type())
1696  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1697 #endif
1698 }
1699 
1700 SWIGRUNTIME PyObject *
1701 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1702 
1703 SWIGRUNTIME void
1704 SwigPyObject_dealloc(PyObject *v)
1705 {
1706  SwigPyObject *sobj = (SwigPyObject *) v;
1707  PyObject *next = sobj->next;
1708  if (sobj->own == SWIG_POINTER_OWN) {
1709  swig_type_info *ty = sobj->ty;
1710  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1711  PyObject *destroy = data ? data->destroy : 0;
1712  if (destroy) {
1713  /* destroy is always a VARARGS method */
1714  PyObject *res;
1715 
1716  /* PyObject_CallFunction() has the potential to silently drop
1717  the active active exception. In cases of unnamed temporary
1718  variable or where we just finished iterating over a generator
1719  StopIteration will be active right now, and this needs to
1720  remain true upon return from SwigPyObject_dealloc. So save
1721  and restore. */
1722 
1723  PyObject *val = NULL, *type = NULL, *tb = NULL;
1724  PyErr_Fetch(&val, &type, &tb);
1725 
1726  if (data->delargs) {
1727  /* we need to create a temporary object to carry the destroy operation */
1728  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1729  res = SWIG_Python_CallFunctor(destroy, tmp);
1730  Py_DECREF(tmp);
1731  } else {
1732  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1733  PyObject *mself = PyCFunction_GET_SELF(destroy);
1734  res = ((*meth)(mself, v));
1735  }
1736  if (!res)
1737  PyErr_WriteUnraisable(destroy);
1738 
1739  PyErr_Restore(val, type, tb);
1740 
1741  Py_XDECREF(res);
1742  }
1743 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1744  else {
1745  const char *name = SWIG_TypePrettyName(ty);
1746  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1747  }
1748 #endif
1749  }
1750  Py_XDECREF(next);
1751  PyObject_DEL(v);
1752 }
1753 
1754 SWIGRUNTIME PyObject*
1755 SwigPyObject_append(PyObject* v, PyObject* next)
1756 {
1757  SwigPyObject *sobj = (SwigPyObject *) v;
1758 #ifndef METH_O
1759  PyObject *tmp = 0;
1760  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1761  next = tmp;
1762 #endif
1763  if (!SwigPyObject_Check(next)) {
1764  PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1765  return NULL;
1766  }
1767  sobj->next = next;
1768  Py_INCREF(next);
1769  return SWIG_Py_Void();
1770 }
1771 
1772 SWIGRUNTIME PyObject*
1773 #ifdef METH_NOARGS
1774 SwigPyObject_next(PyObject* v)
1775 #else
1776 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1777 #endif
1778 {
1779  SwigPyObject *sobj = (SwigPyObject *) v;
1780  if (sobj->next) {
1781  Py_INCREF(sobj->next);
1782  return sobj->next;
1783  } else {
1784  return SWIG_Py_Void();
1785  }
1786 }
1787 
1788 SWIGINTERN PyObject*
1789 #ifdef METH_NOARGS
1790 SwigPyObject_disown(PyObject *v)
1791 #else
1792 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1793 #endif
1794 {
1795  SwigPyObject *sobj = (SwigPyObject *)v;
1796  sobj->own = 0;
1797  return SWIG_Py_Void();
1798 }
1799 
1800 SWIGINTERN PyObject*
1801 #ifdef METH_NOARGS
1802 SwigPyObject_acquire(PyObject *v)
1803 #else
1804 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1805 #endif
1806 {
1807  SwigPyObject *sobj = (SwigPyObject *)v;
1808  sobj->own = SWIG_POINTER_OWN;
1809  return SWIG_Py_Void();
1810 }
1811 
1812 SWIGINTERN PyObject*
1813 SwigPyObject_own(PyObject *v, PyObject *args)
1814 {
1815  PyObject *val = 0;
1816 #if (PY_VERSION_HEX < 0x02020000)
1817  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1818 #elif (PY_VERSION_HEX < 0x02050000)
1819  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1820 #else
1821  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1822 #endif
1823  {
1824  return NULL;
1825  }
1826  else
1827  {
1828  SwigPyObject *sobj = (SwigPyObject *)v;
1829  PyObject *obj = PyBool_FromLong(sobj->own);
1830  if (val) {
1831 #ifdef METH_NOARGS
1832  if (PyObject_IsTrue(val)) {
1833  SwigPyObject_acquire(v);
1834  } else {
1835  SwigPyObject_disown(v);
1836  }
1837 #else
1838  if (PyObject_IsTrue(val)) {
1839  SwigPyObject_acquire(v,args);
1840  } else {
1841  SwigPyObject_disown(v,args);
1842  }
1843 #endif
1844  }
1845  return obj;
1846  }
1847 }
1848 
1849 #ifdef METH_O
1850 static PyMethodDef
1851 swigobject_methods[] = {
1852  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1853  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1854  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1855  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1856  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1857  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1858  {0, 0, 0, 0}
1859 };
1860 #else
1861 static PyMethodDef
1862 swigobject_methods[] = {
1863  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1864  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1865  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1866  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1867  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1868  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1869  {0, 0, 0, 0}
1870 };
1871 #endif
1872 
1873 #if PY_VERSION_HEX < 0x02020000
1874 SWIGINTERN PyObject *
1875 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1876 {
1877  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1878 }
1879 #endif
1880 
1881 SWIGRUNTIME PyTypeObject*
1882 SwigPyObject_TypeOnce(void) {
1883  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1884 
1885  static PyNumberMethods SwigPyObject_as_number = {
1886  (binaryfunc)0, /*nb_add*/
1887  (binaryfunc)0, /*nb_subtract*/
1888  (binaryfunc)0, /*nb_multiply*/
1889  /* nb_divide removed in Python 3 */
1890 #if PY_VERSION_HEX < 0x03000000
1891  (binaryfunc)0, /*nb_divide*/
1892 #endif
1893  (binaryfunc)0, /*nb_remainder*/
1894  (binaryfunc)0, /*nb_divmod*/
1895  (ternaryfunc)0,/*nb_power*/
1896  (unaryfunc)0, /*nb_negative*/
1897  (unaryfunc)0, /*nb_positive*/
1898  (unaryfunc)0, /*nb_absolute*/
1899  (inquiry)0, /*nb_nonzero*/
1900  0, /*nb_invert*/
1901  0, /*nb_lshift*/
1902  0, /*nb_rshift*/
1903  0, /*nb_and*/
1904  0, /*nb_xor*/
1905  0, /*nb_or*/
1906 #if PY_VERSION_HEX < 0x03000000
1907  0, /*nb_coerce*/
1908 #endif
1909  (unaryfunc)SwigPyObject_long, /*nb_int*/
1910 #if PY_VERSION_HEX < 0x03000000
1911  (unaryfunc)SwigPyObject_long, /*nb_long*/
1912 #else
1913  0, /*nb_reserved*/
1914 #endif
1915  (unaryfunc)0, /*nb_float*/
1916 #if PY_VERSION_HEX < 0x03000000
1917  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1918  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1919 #endif
1920 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1921  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1922 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1923  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1924 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1925  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1926 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1927  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1928 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1929  0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1930 #endif
1931  };
1932 
1933  static PyTypeObject swigpyobject_type;
1934  static int type_init = 0;
1935  if (!type_init) {
1936  const PyTypeObject tmp = {
1937  /* PyObject header changed in Python 3 */
1938 #if PY_VERSION_HEX >= 0x03000000
1939  PyVarObject_HEAD_INIT(NULL, 0)
1940 #else
1941  PyObject_HEAD_INIT(NULL)
1942  0, /* ob_size */
1943 #endif
1944  (char *)"SwigPyObject", /* tp_name */
1945  sizeof(SwigPyObject), /* tp_basicsize */
1946  0, /* tp_itemsize */
1947  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1948  0, /* tp_print */
1949 #if PY_VERSION_HEX < 0x02020000
1950  (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1951 #else
1952  (getattrfunc)0, /* tp_getattr */
1953 #endif
1954  (setattrfunc)0, /* tp_setattr */
1955 #if PY_VERSION_HEX >= 0x03000000
1956  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1957 #else
1958  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1959 #endif
1960  (reprfunc)SwigPyObject_repr, /* tp_repr */
1961  &SwigPyObject_as_number, /* tp_as_number */
1962  0, /* tp_as_sequence */
1963  0, /* tp_as_mapping */
1964  (hashfunc)0, /* tp_hash */
1965  (ternaryfunc)0, /* tp_call */
1966  0, /* tp_str */
1967  PyObject_GenericGetAttr, /* tp_getattro */
1968  0, /* tp_setattro */
1969  0, /* tp_as_buffer */
1970  Py_TPFLAGS_DEFAULT, /* tp_flags */
1971  swigobject_doc, /* tp_doc */
1972  0, /* tp_traverse */
1973  0, /* tp_clear */
1974  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1975  0, /* tp_weaklistoffset */
1976 #if PY_VERSION_HEX >= 0x02020000
1977  0, /* tp_iter */
1978  0, /* tp_iternext */
1979  swigobject_methods, /* tp_methods */
1980  0, /* tp_members */
1981  0, /* tp_getset */
1982  0, /* tp_base */
1983  0, /* tp_dict */
1984  0, /* tp_descr_get */
1985  0, /* tp_descr_set */
1986  0, /* tp_dictoffset */
1987  0, /* tp_init */
1988  0, /* tp_alloc */
1989  0, /* tp_new */
1990  0, /* tp_free */
1991  0, /* tp_is_gc */
1992  0, /* tp_bases */
1993  0, /* tp_mro */
1994  0, /* tp_cache */
1995  0, /* tp_subclasses */
1996  0, /* tp_weaklist */
1997 #endif
1998 #if PY_VERSION_HEX >= 0x02030000
1999  0, /* tp_del */
2000 #endif
2001 #if PY_VERSION_HEX >= 0x02060000
2002  0, /* tp_version_tag */
2003 #endif
2004 #if PY_VERSION_HEX >= 0x03040000
2005  0, /* tp_finalize */
2006 #endif
2007 #ifdef COUNT_ALLOCS
2008  0, /* tp_allocs */
2009  0, /* tp_frees */
2010  0, /* tp_maxalloc */
2011 #if PY_VERSION_HEX >= 0x02050000
2012  0, /* tp_prev */
2013 #endif
2014  0 /* tp_next */
2015 #endif
2016  };
2017  swigpyobject_type = tmp;
2018  type_init = 1;
2019 #if PY_VERSION_HEX < 0x02020000
2020  swigpyobject_type.ob_type = &PyType_Type;
2021 #else
2022  if (PyType_Ready(&swigpyobject_type) < 0)
2023  return NULL;
2024 #endif
2025  }
2026  return &swigpyobject_type;
2027 }
2028 
2029 SWIGRUNTIME PyObject *
2030 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2031 {
2032  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2033  if (sobj) {
2034  sobj->ptr = ptr;
2035  sobj->ty = ty;
2036  sobj->own = own;
2037  sobj->next = 0;
2038  }
2039  return (PyObject *)sobj;
2040 }
2041 
2042 /* -----------------------------------------------------------------------------
2043  * Implements a simple Swig Packed type, and use it instead of string
2044  * ----------------------------------------------------------------------------- */
2045 
2046 typedef struct {
2047  PyObject_HEAD
2048  void *pack;
2049  swig_type_info *ty;
2050  size_t size;
2051 } SwigPyPacked;
2052 
2053 SWIGRUNTIME int
2054 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2055 {
2056  char result[SWIG_BUFFER_SIZE];
2057  fputs("<Swig Packed ", fp);
2058  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2059  fputs("at ", fp);
2060  fputs(result, fp);
2061  }
2062  fputs(v->ty->name,fp);
2063  fputs(">", fp);
2064  return 0;
2065 }
2066 
2067 SWIGRUNTIME PyObject *
2068 SwigPyPacked_repr(SwigPyPacked *v)
2069 {
2070  char result[SWIG_BUFFER_SIZE];
2071  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2072  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2073  } else {
2074  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2075  }
2076 }
2077 
2078 SWIGRUNTIME PyObject *
2079 SwigPyPacked_str(SwigPyPacked *v)
2080 {
2081  char result[SWIG_BUFFER_SIZE];
2082  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2083  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2084  } else {
2085  return SWIG_Python_str_FromChar(v->ty->name);
2086  }
2087 }
2088 
2089 SWIGRUNTIME int
2090 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2091 {
2092  size_t i = v->size;
2093  size_t j = w->size;
2094  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2095  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2096 }
2097 
2098 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2099 
2100 SWIGRUNTIME PyTypeObject*
2101 SwigPyPacked_type(void) {
2102  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2103  return type;
2104 }
2105 
2106 SWIGRUNTIMEINLINE int
2107 SwigPyPacked_Check(PyObject *op) {
2108  return ((op)->ob_type == SwigPyPacked_TypeOnce())
2109  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2110 }
2111 
2112 SWIGRUNTIME void
2113 SwigPyPacked_dealloc(PyObject *v)
2114 {
2115  if (SwigPyPacked_Check(v)) {
2116  SwigPyPacked *sobj = (SwigPyPacked *) v;
2117  free(sobj->pack);
2118  }
2119  PyObject_DEL(v);
2120 }
2121 
2122 SWIGRUNTIME PyTypeObject*
2123 SwigPyPacked_TypeOnce(void) {
2124  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2125  static PyTypeObject swigpypacked_type;
2126  static int type_init = 0;
2127  if (!type_init) {
2128  const PyTypeObject tmp = {
2129  /* PyObject header changed in Python 3 */
2130 #if PY_VERSION_HEX>=0x03000000
2131  PyVarObject_HEAD_INIT(NULL, 0)
2132 #else
2133  PyObject_HEAD_INIT(NULL)
2134  0, /* ob_size */
2135 #endif
2136  (char *)"SwigPyPacked", /* tp_name */
2137  sizeof(SwigPyPacked), /* tp_basicsize */
2138  0, /* tp_itemsize */
2139  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2140  (printfunc)SwigPyPacked_print, /* tp_print */
2141  (getattrfunc)0, /* tp_getattr */
2142  (setattrfunc)0, /* tp_setattr */
2143 #if PY_VERSION_HEX>=0x03000000
2144  0, /* tp_reserved in 3.0.1 */
2145 #else
2146  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2147 #endif
2148  (reprfunc)SwigPyPacked_repr, /* tp_repr */
2149  0, /* tp_as_number */
2150  0, /* tp_as_sequence */
2151  0, /* tp_as_mapping */
2152  (hashfunc)0, /* tp_hash */
2153  (ternaryfunc)0, /* tp_call */
2154  (reprfunc)SwigPyPacked_str, /* tp_str */
2155  PyObject_GenericGetAttr, /* tp_getattro */
2156  0, /* tp_setattro */
2157  0, /* tp_as_buffer */
2158  Py_TPFLAGS_DEFAULT, /* tp_flags */
2159  swigpacked_doc, /* tp_doc */
2160  0, /* tp_traverse */
2161  0, /* tp_clear */
2162  0, /* tp_richcompare */
2163  0, /* tp_weaklistoffset */
2164 #if PY_VERSION_HEX >= 0x02020000
2165  0, /* tp_iter */
2166  0, /* tp_iternext */
2167  0, /* tp_methods */
2168  0, /* tp_members */
2169  0, /* tp_getset */
2170  0, /* tp_base */
2171  0, /* tp_dict */
2172  0, /* tp_descr_get */
2173  0, /* tp_descr_set */
2174  0, /* tp_dictoffset */
2175  0, /* tp_init */
2176  0, /* tp_alloc */
2177  0, /* tp_new */
2178  0, /* tp_free */
2179  0, /* tp_is_gc */
2180  0, /* tp_bases */
2181  0, /* tp_mro */
2182  0, /* tp_cache */
2183  0, /* tp_subclasses */
2184  0, /* tp_weaklist */
2185 #endif
2186 #if PY_VERSION_HEX >= 0x02030000
2187  0, /* tp_del */
2188 #endif
2189 #if PY_VERSION_HEX >= 0x02060000
2190  0, /* tp_version_tag */
2191 #endif
2192 #if PY_VERSION_HEX >= 0x03040000
2193  0, /* tp_finalize */
2194 #endif
2195 #ifdef COUNT_ALLOCS
2196  0, /* tp_allocs */
2197  0, /* tp_frees */
2198  0, /* tp_maxalloc */
2199 #if PY_VERSION_HEX >= 0x02050000
2200  0, /* tp_prev */
2201 #endif
2202  0 /* tp_next */
2203 #endif
2204  };
2205  swigpypacked_type = tmp;
2206  type_init = 1;
2207 #if PY_VERSION_HEX < 0x02020000
2208  swigpypacked_type.ob_type = &PyType_Type;
2209 #else
2210  if (PyType_Ready(&swigpypacked_type) < 0)
2211  return NULL;
2212 #endif
2213  }
2214  return &swigpypacked_type;
2215 }
2216 
2217 SWIGRUNTIME PyObject *
2218 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2219 {
2220  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2221  if (sobj) {
2222  void *pack = malloc(size);
2223  if (pack) {
2224  memcpy(pack, ptr, size);
2225  sobj->pack = pack;
2226  sobj->ty = ty;
2227  sobj->size = size;
2228  } else {
2229  PyObject_DEL((PyObject *) sobj);
2230  sobj = 0;
2231  }
2232  }
2233  return (PyObject *) sobj;
2234 }
2235 
2236 SWIGRUNTIME swig_type_info *
2237 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2238 {
2239  if (SwigPyPacked_Check(obj)) {
2240  SwigPyPacked *sobj = (SwigPyPacked *)obj;
2241  if (sobj->size != size) return 0;
2242  memcpy(ptr, sobj->pack, size);
2243  return sobj->ty;
2244  } else {
2245  return 0;
2246  }
2247 }
2248 
2249 /* -----------------------------------------------------------------------------
2250  * pointers/data manipulation
2251  * ----------------------------------------------------------------------------- */
2252 
2253 SWIGRUNTIMEINLINE PyObject *
2254 _SWIG_This(void)
2255 {
2256  return SWIG_Python_str_FromChar("this");
2257 }
2258 
2259 static PyObject *swig_this = NULL;
2260 
2261 SWIGRUNTIME PyObject *
2262 SWIG_This(void)
2263 {
2264  if (swig_this == NULL)
2265  swig_this = _SWIG_This();
2266  return swig_this;
2267 }
2268 
2269 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2270 
2271 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2272 #if PY_VERSION_HEX>=0x03000000
2273 #define SWIG_PYTHON_SLOW_GETSET_THIS
2274 #endif
2275 
2276 SWIGRUNTIME SwigPyObject *
2277 SWIG_Python_GetSwigThis(PyObject *pyobj)
2278 {
2279  PyObject *obj;
2280 
2281  if (SwigPyObject_Check(pyobj))
2282  return (SwigPyObject *) pyobj;
2283 
2284 #ifdef SWIGPYTHON_BUILTIN
2285  (void)obj;
2286 # ifdef PyWeakref_CheckProxy
2287  if (PyWeakref_CheckProxy(pyobj)) {
2288  pyobj = PyWeakref_GET_OBJECT(pyobj);
2289  if (pyobj && SwigPyObject_Check(pyobj))
2290  return (SwigPyObject*) pyobj;
2291  }
2292 # endif
2293  return NULL;
2294 #else
2295 
2296  obj = 0;
2297 
2298 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2299  if (PyInstance_Check(pyobj)) {
2300  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2301  } else {
2302  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2303  if (dictptr != NULL) {
2304  PyObject *dict = *dictptr;
2305  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2306  } else {
2307 #ifdef PyWeakref_CheckProxy
2308  if (PyWeakref_CheckProxy(pyobj)) {
2309  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2310  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2311  }
2312 #endif
2313  obj = PyObject_GetAttr(pyobj,SWIG_This());
2314  if (obj) {
2315  Py_DECREF(obj);
2316  } else {
2317  if (PyErr_Occurred()) PyErr_Clear();
2318  return 0;
2319  }
2320  }
2321  }
2322 #else
2323  obj = PyObject_GetAttr(pyobj,SWIG_This());
2324  if (obj) {
2325  Py_DECREF(obj);
2326  } else {
2327  if (PyErr_Occurred()) PyErr_Clear();
2328  return 0;
2329  }
2330 #endif
2331  if (obj && !SwigPyObject_Check(obj)) {
2332  /* a PyObject is called 'this', try to get the 'real this'
2333  SwigPyObject from it */
2334  return SWIG_Python_GetSwigThis(obj);
2335  }
2336  return (SwigPyObject *)obj;
2337 #endif
2338 }
2339 
2340 /* Acquire a pointer value */
2341 
2342 SWIGRUNTIME int
2343 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2344  if (own == SWIG_POINTER_OWN) {
2345  SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2346  if (sobj) {
2347  int oldown = sobj->own;
2348  sobj->own = own;
2349  return oldown;
2350  }
2351  }
2352  return 0;
2353 }
2354 
2355 /* Convert a pointer value */
2356 
2357 SWIGRUNTIME int
2358 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2359  int res;
2360  SwigPyObject *sobj;
2361  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2362 
2363  if (!obj)
2364  return SWIG_ERROR;
2365  if (obj == Py_None && !implicit_conv) {
2366  if (ptr)
2367  *ptr = 0;
2368  return SWIG_OK;
2369  }
2370 
2371  res = SWIG_ERROR;
2372 
2373  sobj = SWIG_Python_GetSwigThis(obj);
2374  if (own)
2375  *own = 0;
2376  while (sobj) {
2377  void *vptr = sobj->ptr;
2378  if (ty) {
2379  swig_type_info *to = sobj->ty;
2380  if (to == ty) {
2381  /* no type cast needed */
2382  if (ptr) *ptr = vptr;
2383  break;
2384  } else {
2385  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2386  if (!tc) {
2387  sobj = (SwigPyObject *)sobj->next;
2388  } else {
2389  if (ptr) {
2390  int newmemory = 0;
2391  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2392  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2393  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2394  if (own)
2395  *own = *own | SWIG_CAST_NEW_MEMORY;
2396  }
2397  }
2398  break;
2399  }
2400  }
2401  } else {
2402  if (ptr) *ptr = vptr;
2403  break;
2404  }
2405  }
2406  if (sobj) {
2407  if (own)
2408  *own = *own | sobj->own;
2409  if (flags & SWIG_POINTER_DISOWN) {
2410  sobj->own = 0;
2411  }
2412  res = SWIG_OK;
2413  } else {
2414  if (implicit_conv) {
2415  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2416  if (data && !data->implicitconv) {
2417  PyObject *klass = data->klass;
2418  if (klass) {
2419  PyObject *impconv;
2420  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2421  impconv = SWIG_Python_CallFunctor(klass, obj);
2422  data->implicitconv = 0;
2423  if (PyErr_Occurred()) {
2424  PyErr_Clear();
2425  impconv = 0;
2426  }
2427  if (impconv) {
2428  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2429  if (iobj) {
2430  void *vptr;
2431  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2432  if (SWIG_IsOK(res)) {
2433  if (ptr) {
2434  *ptr = vptr;
2435  /* transfer the ownership to 'ptr' */
2436  iobj->own = 0;
2437  res = SWIG_AddCast(res);
2438  res = SWIG_AddNewMask(res);
2439  } else {
2440  res = SWIG_AddCast(res);
2441  }
2442  }
2443  }
2444  Py_DECREF(impconv);
2445  }
2446  }
2447  }
2448  }
2449  if (!SWIG_IsOK(res) && obj == Py_None) {
2450  if (ptr)
2451  *ptr = 0;
2452  if (PyErr_Occurred())
2453  PyErr_Clear();
2454  res = SWIG_OK;
2455  }
2456  }
2457  return res;
2458 }
2459 
2460 /* Convert a function ptr value */
2461 
2462 SWIGRUNTIME int
2463 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2464  if (!PyCFunction_Check(obj)) {
2465  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2466  } else {
2467  void *vptr = 0;
2468 
2469  /* here we get the method pointer for callbacks */
2470  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2471  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2472  if (desc)
2473  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2474  if (!desc)
2475  return SWIG_ERROR;
2476  if (ty) {
2477  swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2478  if (tc) {
2479  int newmemory = 0;
2480  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2481  assert(!newmemory); /* newmemory handling not yet implemented */
2482  } else {
2483  return SWIG_ERROR;
2484  }
2485  } else {
2486  *ptr = vptr;
2487  }
2488  return SWIG_OK;
2489  }
2490 }
2491 
2492 /* Convert a packed value value */
2493 
2494 SWIGRUNTIME int
2495 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2496  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2497  if (!to) return SWIG_ERROR;
2498  if (ty) {
2499  if (to != ty) {
2500  /* check type cast? */
2501  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2502  if (!tc) return SWIG_ERROR;
2503  }
2504  }
2505  return SWIG_OK;
2506 }
2507 
2508 /* -----------------------------------------------------------------------------
2509  * Create a new pointer object
2510  * ----------------------------------------------------------------------------- */
2511 
2512 /*
2513  Create a new instance object, without calling __init__, and set the
2514  'this' attribute.
2515 */
2516 
2517 SWIGRUNTIME PyObject*
2518 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2519 {
2520 #if (PY_VERSION_HEX >= 0x02020000)
2521  PyObject *inst = 0;
2522  PyObject *newraw = data->newraw;
2523  if (newraw) {
2524  inst = PyObject_Call(newraw, data->newargs, NULL);
2525  if (inst) {
2526 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2527  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2528  if (dictptr != NULL) {
2529  PyObject *dict = *dictptr;
2530  if (dict == NULL) {
2531  dict = PyDict_New();
2532  *dictptr = dict;
2533  PyDict_SetItem(dict, SWIG_This(), swig_this);
2534  }
2535  }
2536 #else
2537  PyObject *key = SWIG_This();
2538  PyObject_SetAttr(inst, key, swig_this);
2539 #endif
2540  }
2541  } else {
2542 #if PY_VERSION_HEX >= 0x03000000
2543  inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2544  if (inst) {
2545  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2546  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2547  }
2548 #else
2549  PyObject *dict = PyDict_New();
2550  if (dict) {
2551  PyDict_SetItem(dict, SWIG_This(), swig_this);
2552  inst = PyInstance_NewRaw(data->newargs, dict);
2553  Py_DECREF(dict);
2554  }
2555 #endif
2556  }
2557  return inst;
2558 #else
2559 #if (PY_VERSION_HEX >= 0x02010000)
2560  PyObject *inst = 0;
2561  PyObject *dict = PyDict_New();
2562  if (dict) {
2563  PyDict_SetItem(dict, SWIG_This(), swig_this);
2564  inst = PyInstance_NewRaw(data->newargs, dict);
2565  Py_DECREF(dict);
2566  }
2567  return (PyObject *) inst;
2568 #else
2569  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2570  if (inst == NULL) {
2571  return NULL;
2572  }
2573  inst->in_class = (PyClassObject *)data->newargs;
2574  Py_INCREF(inst->in_class);
2575  inst->in_dict = PyDict_New();
2576  if (inst->in_dict == NULL) {
2577  Py_DECREF(inst);
2578  return NULL;
2579  }
2580 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2581  inst->in_weakreflist = NULL;
2582 #endif
2583 #ifdef Py_TPFLAGS_GC
2584  PyObject_GC_Init(inst);
2585 #endif
2586  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2587  return (PyObject *) inst;
2588 #endif
2589 #endif
2590 }
2591 
2592 SWIGRUNTIME void
2593 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2594 {
2595  PyObject *dict;
2596 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2597  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2598  if (dictptr != NULL) {
2599  dict = *dictptr;
2600  if (dict == NULL) {
2601  dict = PyDict_New();
2602  *dictptr = dict;
2603  }
2604  PyDict_SetItem(dict, SWIG_This(), swig_this);
2605  return;
2606  }
2607 #endif
2608  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2609  PyDict_SetItem(dict, SWIG_This(), swig_this);
2610  Py_DECREF(dict);
2611 }
2612 
2613 
2614 SWIGINTERN PyObject *
2615 SWIG_Python_InitShadowInstance(PyObject *args) {
2616  PyObject *obj[2];
2617  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2618  return NULL;
2619  } else {
2620  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2621  if (sthis) {
2622  SwigPyObject_append((PyObject*) sthis, obj[1]);
2623  } else {
2624  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2625  }
2626  return SWIG_Py_Void();
2627  }
2628 }
2629 
2630 /* Create a new pointer object */
2631 
2632 SWIGRUNTIME PyObject *
2633 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2634  SwigPyClientData *clientdata;
2635  PyObject * robj;
2636  int own;
2637 
2638  if (!ptr)
2639  return SWIG_Py_Void();
2640 
2641  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2642  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2643  if (clientdata && clientdata->pytype) {
2644  SwigPyObject *newobj;
2645  if (flags & SWIG_BUILTIN_TP_INIT) {
2646  newobj = (SwigPyObject*) self;
2647  if (newobj->ptr) {
2648  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2649  while (newobj->next)
2650  newobj = (SwigPyObject *) newobj->next;
2651  newobj->next = next_self;
2652  newobj = (SwigPyObject *)next_self;
2653 #ifdef SWIGPYTHON_BUILTIN
2654  newobj->dict = 0;
2655 #endif
2656  }
2657  } else {
2658  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2659 #ifdef SWIGPYTHON_BUILTIN
2660  newobj->dict = 0;
2661 #endif
2662  }
2663  if (newobj) {
2664  newobj->ptr = ptr;
2665  newobj->ty = type;
2666  newobj->own = own;
2667  newobj->next = 0;
2668  return (PyObject*) newobj;
2669  }
2670  return SWIG_Py_Void();
2671  }
2672 
2673  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2674 
2675  robj = SwigPyObject_New(ptr, type, own);
2676  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2677  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2678  Py_DECREF(robj);
2679  robj = inst;
2680  }
2681  return robj;
2682 }
2683 
2684 /* Create a new packed object */
2685 
2686 SWIGRUNTIMEINLINE PyObject *
2687 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2688  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2689 }
2690 
2691 /* -----------------------------------------------------------------------------*
2692  * Get type list
2693  * -----------------------------------------------------------------------------*/
2694 
2695 #ifdef SWIG_LINK_RUNTIME
2696 void *SWIG_ReturnGlobalTypeList(void *);
2697 #endif
2698 
2699 SWIGRUNTIME swig_module_info *
2700 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2701  static void *type_pointer = (void *)0;
2702  /* first check if module already created */
2703  if (!type_pointer) {
2704 #ifdef SWIG_LINK_RUNTIME
2705  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2706 #else
2707 # ifdef SWIGPY_USE_CAPSULE
2708  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2709 # else
2710  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2711  (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2712 # endif
2713  if (PyErr_Occurred()) {
2714  PyErr_Clear();
2715  type_pointer = (void *)0;
2716  }
2717 #endif
2718  }
2719  return (swig_module_info *) type_pointer;
2720 }
2721 
2722 #if PY_MAJOR_VERSION < 2
2723 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2724  is copied out of Python/modsupport.c in python version 2.3.4 */
2725 SWIGINTERN int
2726 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2727 {
2728  PyObject *dict;
2729  if (!PyModule_Check(m)) {
2730  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2731  return SWIG_ERROR;
2732  }
2733  if (!o) {
2734  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2735  return SWIG_ERROR;
2736  }
2737 
2738  dict = PyModule_GetDict(m);
2739  if (dict == NULL) {
2740  /* Internal error -- modules must have a dict! */
2741  PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2742  PyModule_GetName(m));
2743  return SWIG_ERROR;
2744  }
2745  if (PyDict_SetItemString(dict, name, o))
2746  return SWIG_ERROR;
2747  Py_DECREF(o);
2748  return SWIG_OK;
2749 }
2750 #endif
2751 
2752 SWIGRUNTIME void
2753 #ifdef SWIGPY_USE_CAPSULE
2754 SWIG_Python_DestroyModule(PyObject *obj)
2755 #else
2756 SWIG_Python_DestroyModule(void *vptr)
2757 #endif
2758 {
2759 #ifdef SWIGPY_USE_CAPSULE
2760  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2761 #else
2762  swig_module_info *swig_module = (swig_module_info *) vptr;
2763 #endif
2764  swig_type_info **types = swig_module->types;
2765  size_t i;
2766  for (i =0; i < swig_module->size; ++i) {
2767  swig_type_info *ty = types[i];
2768  if (ty->owndata) {
2769  SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2770  if (data) SwigPyClientData_Del(data);
2771  }
2772  }
2773  Py_DECREF(SWIG_This());
2774  swig_this = NULL;
2775 }
2776 
2777 SWIGRUNTIME void
2778 SWIG_Python_SetModule(swig_module_info *swig_module) {
2779 #if PY_VERSION_HEX >= 0x03000000
2780  /* Add a dummy module object into sys.modules */
2781  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2782 #else
2783  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2784  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2785 #endif
2786 #ifdef SWIGPY_USE_CAPSULE
2787  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2788  if (pointer && module) {
2789  PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2790  } else {
2791  Py_XDECREF(pointer);
2792  }
2793 #else
2794  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2795  if (pointer && module) {
2796  PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2797  } else {
2798  Py_XDECREF(pointer);
2799  }
2800 #endif
2801 }
2802 
2803 /* The python cached type query */
2804 SWIGRUNTIME PyObject *
2805 SWIG_Python_TypeCache(void) {
2806  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2807  return cache;
2808 }
2809 
2810 SWIGRUNTIME swig_type_info *
2811 SWIG_Python_TypeQuery(const char *type)
2812 {
2813  PyObject *cache = SWIG_Python_TypeCache();
2814  PyObject *key = SWIG_Python_str_FromChar(type);
2815  PyObject *obj = PyDict_GetItem(cache, key);
2816  swig_type_info *descriptor;
2817  if (obj) {
2818 #ifdef SWIGPY_USE_CAPSULE
2819  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2820 #else
2821  descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2822 #endif
2823  } else {
2824  swig_module_info *swig_module = SWIG_GetModule(0);
2825  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2826  if (descriptor) {
2827 #ifdef SWIGPY_USE_CAPSULE
2828  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2829 #else
2830  obj = PyCObject_FromVoidPtr(descriptor, NULL);
2831 #endif
2832  PyDict_SetItem(cache, key, obj);
2833  Py_DECREF(obj);
2834  }
2835  }
2836  Py_DECREF(key);
2837  return descriptor;
2838 }
2839 
2840 /*
2841  For backward compatibility only
2842 */
2843 #define SWIG_POINTER_EXCEPTION 0
2844 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2845 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2846 
2847 SWIGRUNTIME int
2848 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2849 {
2850  if (PyErr_Occurred()) {
2851  PyObject *type = 0;
2852  PyObject *value = 0;
2853  PyObject *traceback = 0;
2854  PyErr_Fetch(&type, &value, &traceback);
2855  if (value) {
2856  char *tmp;
2857  PyObject *old_str = PyObject_Str(value);
2858  Py_XINCREF(type);
2859  PyErr_Clear();
2860  if (infront) {
2861  PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2862  } else {
2863  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2864  }
2865  SWIG_Python_str_DelForPy3(tmp);
2866  Py_DECREF(old_str);
2867  }
2868  return 1;
2869  } else {
2870  return 0;
2871  }
2872 }
2873 
2874 SWIGRUNTIME int
2875 SWIG_Python_ArgFail(int argnum)
2876 {
2877  if (PyErr_Occurred()) {
2878  /* add information about failing argument */
2879  char mesg[256];
2880  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2881  return SWIG_Python_AddErrMesg(mesg, 1);
2882  } else {
2883  return 0;
2884  }
2885 }
2886 
2887 SWIGRUNTIMEINLINE const char *
2888 SwigPyObject_GetDesc(PyObject *self)
2889 {
2890  SwigPyObject *v = (SwigPyObject *)self;
2891  swig_type_info *ty = v ? v->ty : 0;
2892  return ty ? ty->str : "";
2893 }
2894 
2895 SWIGRUNTIME void
2896 SWIG_Python_TypeError(const char *type, PyObject *obj)
2897 {
2898  if (type) {
2899 #if defined(SWIG_COBJECT_TYPES)
2900  if (obj && SwigPyObject_Check(obj)) {
2901  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2902  if (otype) {
2903  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2904  type, otype);
2905  return;
2906  }
2907  } else
2908 #endif
2909  {
2910  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2911  if (otype) {
2912  PyObject *str = PyObject_Str(obj);
2913  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2914  if (cstr) {
2915  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2916  type, otype, cstr);
2917  SWIG_Python_str_DelForPy3(cstr);
2918  } else {
2919  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2920  type, otype);
2921  }
2922  Py_XDECREF(str);
2923  return;
2924  }
2925  }
2926  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2927  } else {
2928  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2929  }
2930 }
2931 
2932 
2933 /* Convert a pointer value, signal an exception on a type mismatch */
2934 SWIGRUNTIME void *
2935 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2936  void *result;
2937  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2938  PyErr_Clear();
2939 #if SWIG_POINTER_EXCEPTION
2940  if (flags) {
2941  SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2942  SWIG_Python_ArgFail(argnum);
2943  }
2944 #endif
2945  }
2946  return result;
2947 }
2948 
2949 #ifdef SWIGPYTHON_BUILTIN
2950 SWIGRUNTIME int
2951 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2952  PyTypeObject *tp = obj->ob_type;
2953  PyObject *descr;
2954  PyObject *encoded_name;
2955  descrsetfunc f;
2956  int res = -1;
2957 
2958 # ifdef Py_USING_UNICODE
2959  if (PyString_Check(name)) {
2960  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2961  if (!name)
2962  return -1;
2963  } else if (!PyUnicode_Check(name))
2964 # else
2965  if (!PyString_Check(name))
2966 # endif
2967  {
2968  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2969  return -1;
2970  } else {
2971  Py_INCREF(name);
2972  }
2973 
2974  if (!tp->tp_dict) {
2975  if (PyType_Ready(tp) < 0)
2976  goto done;
2977  }
2978 
2979  descr = _PyType_Lookup(tp, name);
2980  f = NULL;
2981  if (descr != NULL)
2982  f = descr->ob_type->tp_descr_set;
2983  if (!f) {
2984  if (PyString_Check(name)) {
2985  encoded_name = name;
2986  Py_INCREF(name);
2987  } else {
2988  encoded_name = PyUnicode_AsUTF8String(name);
2989  }
2990  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2991  Py_DECREF(encoded_name);
2992  } else {
2993  res = f(descr, obj, value);
2994  }
2995 
2996  done:
2997  Py_DECREF(name);
2998  return res;
2999 }
3000 #endif
3001 
3002 
3003 #ifdef __cplusplus
3004 }
3005 #endif
3006 
3007 
3008 
3009 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3010 
3011 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
3012 
3013 
3014 
3015  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
3016 
3017 /* -----------------------------------------------------------------------------
3018  * director_common.swg
3019  *
3020  * This file contains support for director classes which is common between
3021  * languages.
3022  * ----------------------------------------------------------------------------- */
3023 
3024 /*
3025  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
3026  'Swig' namespace. This could be useful for multi-modules projects.
3027 */
3028 #ifdef SWIG_DIRECTOR_STATIC
3029 /* Force anonymous (static) namespace */
3030 #define Swig
3031 #endif
3032 /* -----------------------------------------------------------------------------
3033  * director.swg
3034  *
3035  * This file contains support for director classes so that Python proxy
3036  * methods can be called from C++.
3037  * ----------------------------------------------------------------------------- */
3038 
3039 #ifndef SWIG_DIRECTOR_PYTHON_HEADER_
3040 #define SWIG_DIRECTOR_PYTHON_HEADER_
3041 
3042 #include <string>
3043 #include <iostream>
3044 #include <exception>
3045 #include <vector>
3046 #include <map>
3047 
3048 
3049 /*
3050  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
3051  table', and avoid multiple GetAttr calls to retrieve the python
3052  methods.
3053 */
3054 
3055 #ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
3056 #ifndef SWIG_PYTHON_DIRECTOR_VTABLE
3057 #define SWIG_PYTHON_DIRECTOR_VTABLE
3058 #endif
3059 #endif
3060 
3061 
3062 
3063 /*
3064  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
3065  Undefined Exception Handler provided by swig.
3066 */
3067 #ifndef SWIG_DIRECTOR_NO_UEH
3068 #ifndef SWIG_DIRECTOR_UEH
3069 #define SWIG_DIRECTOR_UEH
3070 #endif
3071 #endif
3072 
3073 
3074 /*
3075  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
3076  native C++ RTTI and dynamic_cast<>. But be aware that directors
3077  could stop working when using this option.
3078 */
3079 #ifdef SWIG_DIRECTOR_NORTTI
3080 /*
3081  When we don't use the native C++ RTTI, we implement a minimal one
3082  only for Directors.
3083 */
3084 # ifndef SWIG_DIRECTOR_RTDIR
3085 # define SWIG_DIRECTOR_RTDIR
3086 
3087 namespace Swig {
3088  class Director;
3089  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
3090  static std::map<void *, Director *> rtdir_map;
3091  return rtdir_map;
3092  }
3093 
3094  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
3095  get_rtdir_map()[vptr] = rtdir;
3096  }
3097 
3098  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
3099  std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
3100  Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
3101  return rtdir;
3102  }
3103 }
3104 # endif /* SWIG_DIRECTOR_RTDIR */
3105 
3106 # define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
3107 # define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)
3108 
3109 #else
3110 
3111 # define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
3112 # define SWIG_DIRECTOR_RGTR(ARG1, ARG2)
3113 
3114 #endif /* SWIG_DIRECTOR_NORTTI */
3115 
3116 extern "C" {
3117  struct swig_type_info;
3118 }
3119 
3120 namespace Swig {
3121 
3122  /* memory handler */
3123  struct GCItem {
3124  virtual ~GCItem() {}
3125 
3126  virtual int get_own() const {
3127  return 0;
3128  }
3129  };
3130 
3131  struct GCItem_var {
3132  GCItem_var(GCItem *item = 0) : _item(item) {
3133  }
3134 
3135  GCItem_var& operator=(GCItem *item) {
3136  GCItem *tmp = _item;
3137  _item = item;
3138  delete tmp;
3139  return *this;
3140  }
3141 
3142  ~GCItem_var() {
3143  delete _item;
3144  }
3145 
3146  GCItem * operator->() const {
3147  return _item;
3148  }
3149 
3150  private:
3151  GCItem *_item;
3152  };
3153 
3155  GCItem_Object(int own) : _own(own) {
3156  }
3157 
3158  virtual ~GCItem_Object() {
3159  }
3160 
3161  int get_own() const {
3162  return _own;
3163  }
3164 
3165  private:
3166  int _own;
3167  };
3168 
3169  template <typename Type>
3170  struct GCItem_T : GCItem {
3171  GCItem_T(Type *ptr) : _ptr(ptr) {
3172  }
3173 
3174  virtual ~GCItem_T() {
3175  delete _ptr;
3176  }
3177 
3178  private:
3179  Type *_ptr;
3180  };
3181 
3182  template <typename Type>
3183  struct GCArray_T : GCItem {
3184  GCArray_T(Type *ptr) : _ptr(ptr) {
3185  }
3186 
3187  virtual ~GCArray_T() {
3188  delete[] _ptr;
3189  }
3190 
3191  private:
3192  Type *_ptr;
3193  };
3194 
3195  /* base class for director exceptions */
3196  class DirectorException : public std::exception {
3197  protected:
3198  std::string swig_msg;
3199  public:
3200  DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) {
3201  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3202  if (msg[0]) {
3203  swig_msg += " ";
3204  swig_msg += msg;
3205  }
3206  if (!PyErr_Occurred()) {
3207  PyErr_SetString(error, what());
3208  }
3209  SWIG_PYTHON_THREAD_END_BLOCK;
3210  }
3211 
3212  virtual ~DirectorException() throw() {
3213  }
3214 
3215  /* Deprecated, use what() instead */
3216  const char *getMessage() const {
3217  return what();
3218  }
3219 
3220  const char *what() const throw() {
3221  return swig_msg.c_str();
3222  }
3223 
3224  static void raise(PyObject *error, const char *msg) {
3225  throw DirectorException(error, msg);
3226  }
3227 
3228  static void raise(const char *msg) {
3229  raise(PyExc_RuntimeError, msg);
3230  }
3231  };
3232 
3233  /* unknown exception handler */
3235 #ifdef SWIG_DIRECTOR_UEH
3236  static void handler() {
3237  try {
3238  throw;
3239  } catch (DirectorException& e) {
3240  std::cerr << "SWIG Director exception caught:" << std::endl
3241  << e.what() << std::endl;
3242  } catch (std::exception& e) {
3243  std::cerr << "std::exception caught: "<< e.what() << std::endl;
3244  } catch (...) {
3245  std::cerr << "Unknown exception caught." << std::endl;
3246  }
3247 
3248  std::cerr << std::endl
3249  << "Python interpreter traceback:" << std::endl;
3250  PyErr_Print();
3251  std::cerr << std::endl;
3252 
3253  std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
3254  << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
3255  << std::endl
3256  << "Exception is being re-thrown, program will likely abort/terminate." << std::endl;
3257  throw;
3258  }
3259 
3260  public:
3261 
3262  std::unexpected_handler old;
3263  UnknownExceptionHandler(std::unexpected_handler nh = handler) {
3264  old = std::set_unexpected(nh);
3265  }
3266 
3268  std::set_unexpected(old);
3269  }
3270 #endif
3271  };
3272 
3273  /* type mismatch in the return value from a python method call */
3275  public:
3276  DirectorTypeMismatchException(PyObject *error, const char *msg="")
3277  : DirectorException(error, "SWIG director type mismatch", msg) {
3278  }
3279 
3280  DirectorTypeMismatchException(const char *msg="")
3281  : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) {
3282  }
3283 
3284  static void raise(PyObject *error, const char *msg) {
3285  throw DirectorTypeMismatchException(error, msg);
3286  }
3287 
3288  static void raise(const char *msg) {
3289  throw DirectorTypeMismatchException(msg);
3290  }
3291  };
3292 
3293  /* any python exception that occurs during a director method call */
3295  public:
3296  DirectorMethodException(const char *msg = "")
3297  : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
3298  }
3299 
3300  static void raise(const char *msg) {
3301  throw DirectorMethodException(msg);
3302  }
3303  };
3304 
3305  /* attempt to call a pure virtual method via a director method */
3307  public:
3308  DirectorPureVirtualException(const char *msg = "")
3309  : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
3310  }
3311 
3312  static void raise(const char *msg) {
3313  throw DirectorPureVirtualException(msg);
3314  }
3315  };
3316 
3317 
3318 #if defined(SWIG_PYTHON_THREADS)
3319 /* __THREAD__ is the old macro to activate some thread support */
3320 # if !defined(__THREAD__)
3321 # define __THREAD__ 1
3322 # endif
3323 #endif
3324 
3325 #ifdef __THREAD__
3326 # include "pythread.h"
3327  class Guard {
3328  PyThread_type_lock &mutex_;
3329 
3330  public:
3331  Guard(PyThread_type_lock & mutex) : mutex_(mutex) {
3332  PyThread_acquire_lock(mutex_, WAIT_LOCK);
3333  }
3334 
3335  ~Guard() {
3336  PyThread_release_lock(mutex_);
3337  }
3338  };
3339 # define SWIG_GUARD(mutex) Guard _guard(mutex)
3340 #else
3341 # define SWIG_GUARD(mutex)
3342 #endif
3343 
3344  /* director base class */
3345  class Director {
3346  private:
3347  /* pointer to the wrapped python object */
3348  PyObject *swig_self;
3349  /* flag indicating whether the object is owned by python or c++ */
3350  mutable bool swig_disown_flag;
3351 
3352  /* decrement the reference count of the wrapped python object */
3353  void swig_decref() const {
3354  if (swig_disown_flag) {
3355  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3356  Py_DECREF(swig_self);
3357  SWIG_PYTHON_THREAD_END_BLOCK;
3358  }
3359  }
3360 
3361  public:
3362  /* wrap a python object. */
3363  Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
3364  }
3365 
3366  /* discard our reference at destruction */
3367  virtual ~Director() {
3368  swig_decref();
3369  }
3370 
3371  /* return a pointer to the wrapped python object */
3372  PyObject *swig_get_self() const {
3373  return swig_self;
3374  }
3375 
3376  /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */
3377  void swig_disown() const {
3378  if (!swig_disown_flag) {
3379  swig_disown_flag=true;
3380  swig_incref();
3381  }
3382  }
3383 
3384  /* increase the reference count of the wrapped python object */
3385  void swig_incref() const {
3386  if (swig_disown_flag) {
3387  Py_INCREF(swig_self);
3388  }
3389  }
3390 
3391  /* methods to implement pseudo protected director members */
3392  virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
3393  return true;
3394  }
3395 
3396  virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
3397  }
3398 
3399  /* ownership management */
3400  private:
3401  typedef std::map<void *, GCItem_var> swig_ownership_map;
3402  mutable swig_ownership_map swig_owner;
3403 #ifdef __THREAD__
3404  static PyThread_type_lock swig_mutex_own;
3405 #endif
3406 
3407  public:
3408  template <typename Type>
3409  void swig_acquire_ownership_array(Type *vptr) const {
3410  if (vptr) {
3411  SWIG_GUARD(swig_mutex_own);
3412  swig_owner[vptr] = new GCArray_T<Type>(vptr);
3413  }
3414  }
3415 
3416  template <typename Type>
3417  void swig_acquire_ownership(Type *vptr) const {
3418  if (vptr) {
3419  SWIG_GUARD(swig_mutex_own);
3420  swig_owner[vptr] = new GCItem_T<Type>(vptr);
3421  }
3422  }
3423 
3424  void swig_acquire_ownership_obj(void *vptr, int own) const {
3425  if (vptr && own) {
3426  SWIG_GUARD(swig_mutex_own);
3427  swig_owner[vptr] = new GCItem_Object(own);
3428  }
3429  }
3430 
3431  int swig_release_ownership(void *vptr) const {
3432  int own = 0;
3433  if (vptr) {
3434  SWIG_GUARD(swig_mutex_own);
3435  swig_ownership_map::iterator iter = swig_owner.find(vptr);
3436  if (iter != swig_owner.end()) {
3437  own = iter->second->get_own();
3438  swig_owner.erase(iter);
3439  }
3440  }
3441  return own;
3442  }
3443 
3444  template <typename Type>
3445  static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) {
3446  SwigPyObject *sobj = (SwigPyObject *)pyobj;
3447  sobj->own = 0;
3448  Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
3449  if (d)
3450  d->swig_disown();
3451  return PyWeakref_NewProxy(pyobj, NULL);
3452  }
3453  };
3454 
3455 #ifdef __THREAD__
3456  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
3457 #endif
3458 }
3459 
3460 #endif
3461 
3462 /* -------- TYPES TABLE (BEGIN) -------- */
3463 
3464 #define SWIGTYPE_p_Pythia8__AlpgenHooks swig_types[0]
3465 #define SWIGTYPE_p_Pythia8__AlpgenPar swig_types[1]
3466 #define SWIGTYPE_p_Pythia8__AlphaEM swig_types[2]
3467 #define SWIGTYPE_p_Pythia8__AlphaStrong swig_types[3]
3468 #define SWIGTYPE_p_Pythia8__Angantyr swig_types[4]
3469 #define SWIGTYPE_p_Pythia8__BeamParticle swig_types[5]
3470 #define SWIGTYPE_p_Pythia8__BeamRemnants swig_types[6]
3471 #define SWIGTYPE_p_Pythia8__BeamShape swig_types[7]
3472 #define SWIGTYPE_p_Pythia8__BlackSubCollisionModel swig_types[8]
3473 #define SWIGTYPE_p_Pythia8__BoseEinstein swig_types[9]
3474 #define SWIGTYPE_p_Pythia8__BoseEinsteinHadron swig_types[10]
3475 #define SWIGTYPE_p_Pythia8__CJKL swig_types[11]
3476 #define SWIGTYPE_p_Pythia8__CTEQ5L swig_types[12]
3477 #define SWIGTYPE_p_Pythia8__CTEQ6pdf swig_types[13]
3478 #define SWIGTYPE_p_Pythia8__CellJet swig_types[14]
3479 #define SWIGTYPE_p_Pythia8__ClusterJet swig_types[15]
3480 #define SWIGTYPE_p_Pythia8__Clustering swig_types[16]
3481 #define SWIGTYPE_p_Pythia8__ColConfig swig_types[17]
3482 #define SWIGTYPE_p_Pythia8__ColSinglet swig_types[18]
3483 #define SWIGTYPE_p_Pythia8__ColourDipole swig_types[19]
3484 #define SWIGTYPE_p_Pythia8__ColourJunction swig_types[20]
3485 #define SWIGTYPE_p_Pythia8__ColourParticle swig_types[21]
3486 #define SWIGTYPE_p_Pythia8__ColourReconnection swig_types[22]
3487 #define SWIGTYPE_p_Pythia8__ColourTracing swig_types[23]
3488 #define SWIGTYPE_p_Pythia8__CombineMatchingInput swig_types[24]
3489 #define SWIGTYPE_p_Pythia8__CoupSM swig_types[25]
3490 #define SWIGTYPE_p_Pythia8__CoupSUSY swig_types[26]
3491 #define SWIGTYPE_p_Pythia8__Couplings swig_types[27]
3492 #define SWIGTYPE_p_Pythia8__DecayChannel swig_types[28]
3493 #define SWIGTYPE_p_Pythia8__DecayHandler swig_types[29]
3494 #define SWIGTYPE_p_Pythia8__DeuteronProduction swig_types[30]
3495 #define SWIGTYPE_p_Pythia8__DoubleStrikman swig_types[31]
3496 #define SWIGTYPE_p_Pythia8__DummyForStreams swig_types[32]
3497 #define SWIGTYPE_p_Pythia8__EPAexternal swig_types[33]
3498 #define SWIGTYPE_p_Pythia8__EPPS16 swig_types[34]
3499 #define SWIGTYPE_p_Pythia8__EPS09 swig_types[35]
3500 #define SWIGTYPE_p_Pythia8__Event swig_types[36]
3501 #define SWIGTYPE_p_Pythia8__EventInfo swig_types[37]
3502 #define SWIGTYPE_p_Pythia8__FVec swig_types[38]
3503 #define SWIGTYPE_p_Pythia8__Flag swig_types[39]
3504 #define SWIGTYPE_p_Pythia8__FlavContainer swig_types[40]
3505 #define SWIGTYPE_p_Pythia8__FlavourRope swig_types[41]
3506 #define SWIGTYPE_p_Pythia8__GLISSANDOModel swig_types[42]
3507 #define SWIGTYPE_p_Pythia8__GRV94L swig_types[43]
3508 #define SWIGTYPE_p_Pythia8__GRVpiL swig_types[44]
3509 #define SWIGTYPE_p_Pythia8__GammaKinematics swig_types[45]
3510 #define SWIGTYPE_p_Pythia8__GammaMatrix swig_types[46]
3511 #define SWIGTYPE_p_Pythia8__GammaPoint swig_types[47]
3512 #define SWIGTYPE_p_Pythia8__HEPEUP swig_types[48]
3513 #define SWIGTYPE_p_Pythia8__HEPRUP swig_types[49]
3514 #define SWIGTYPE_p_Pythia8__HIInfo swig_types[50]
3515 #define SWIGTYPE_p_Pythia8__HIUserHooks swig_types[51]
3516 #define SWIGTYPE_p_Pythia8__HJSlowJet swig_types[52]
3517 #define SWIGTYPE_p_Pythia8__HMEGamma2TwoFermions swig_types[53]
3518 #define SWIGTYPE_p_Pythia8__HMEHiggs2TwoFermions swig_types[54]
3519 #define SWIGTYPE_p_Pythia8__HMETau2FivePions swig_types[55]
3520 #define SWIGTYPE_p_Pythia8__HMETau2FourPions swig_types[56]
3521 #define SWIGTYPE_p_Pythia8__HMETau2Meson swig_types[57]
3522 #define SWIGTYPE_p_Pythia8__HMETau2PhaseSpace swig_types[58]
3523 #define SWIGTYPE_p_Pythia8__HMETau2ThreeMesons swig_types[59]
3524 #define SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsGeneric swig_types[60]
3525 #define SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsWithKaons swig_types[61]
3526 #define SWIGTYPE_p_Pythia8__HMETau2ThreePions swig_types[62]
3527 #define SWIGTYPE_p_Pythia8__HMETau2TwoLeptons swig_types[63]
3528 #define SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVector swig_types[64]
3529 #define SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVectorScalar swig_types[65]
3530 #define SWIGTYPE_p_Pythia8__HMETau2TwoPionsGamma swig_types[66]
3531 #define SWIGTYPE_p_Pythia8__HMETauDecay swig_types[67]
3532 #define SWIGTYPE_p_Pythia8__HMETwoFermions2GammaZ2TwoFermions swig_types[68]
3533 #define SWIGTYPE_p_Pythia8__HMETwoFermions2W2TwoFermions swig_types[69]
3534 #define SWIGTYPE_p_Pythia8__HMEW2TwoFermions swig_types[70]
3535 #define SWIGTYPE_p_Pythia8__HMEX2TwoFermions swig_types[71]
3536 #define SWIGTYPE_p_Pythia8__HMEZ2TwoFermions swig_types[72]
3537 #define SWIGTYPE_p_Pythia8__HVStringFlav swig_types[73]
3538 #define SWIGTYPE_p_Pythia8__HVStringPT swig_types[74]
3539 #define SWIGTYPE_p_Pythia8__HVStringZ swig_types[75]
3540 #define SWIGTYPE_p_Pythia8__HadronLevel swig_types[76]
3541 #define SWIGTYPE_p_Pythia8__HadronScatter swig_types[77]
3542 #define SWIGTYPE_p_Pythia8__HadronScatterPair swig_types[78]
3543 #define SWIGTYPE_p_Pythia8__HardDiffraction swig_types[79]
3544 #define SWIGTYPE_p_Pythia8__HardProcess swig_types[80]
3545 #define SWIGTYPE_p_Pythia8__HeavyIons swig_types[81]
3546 #define SWIGTYPE_p_Pythia8__HelicityMatrixElement swig_types[82]
3547 #define SWIGTYPE_p_Pythia8__HelicityParticle swig_types[83]
3548 #define SWIGTYPE_p_Pythia8__HiddenValleyFragmentation swig_types[84]
3549 #define SWIGTYPE_p_Pythia8__Hist swig_types[85]
3550 #define SWIGTYPE_p_Pythia8__HistPlot swig_types[86]
3551 #define SWIGTYPE_p_Pythia8__History swig_types[87]
3552 #define SWIGTYPE_p_Pythia8__ImpactParameterGenerator swig_types[88]
3553 #define SWIGTYPE_p_Pythia8__InBeam swig_types[89]
3554 #define SWIGTYPE_p_Pythia8__InPair swig_types[90]
3555 #define SWIGTYPE_p_Pythia8__Info swig_types[91]
3556 #define SWIGTYPE_p_Pythia8__Isospin swig_types[92]
3557 #define SWIGTYPE_p_Pythia8__JetMatching swig_types[93]
3558 #define SWIGTYPE_p_Pythia8__JetMatchingAlpgen swig_types[94]
3559 #define SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen swig_types[95]
3560 #define SWIGTYPE_p_Pythia8__JetMatchingMadgraph swig_types[96]
3561 #define SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen swig_types[97]
3562 #define SWIGTYPE_p_Pythia8__Junction swig_types[98]
3563 #define SWIGTYPE_p_Pythia8__JunctionSplitting swig_types[99]
3564 #define SWIGTYPE_p_Pythia8__LHAGrid1 swig_types[100]
3565 #define SWIGTYPE_p_Pythia8__LHAPDF swig_types[101]
3566 #define SWIGTYPE_p_Pythia8__LHAParticle swig_types[102]
3567 #define SWIGTYPE_p_Pythia8__LHAProcess swig_types[103]
3568 #define SWIGTYPE_p_Pythia8__LHAgenerator swig_types[104]
3569 #define SWIGTYPE_p_Pythia8__LHAinitrwgt swig_types[105]
3570 #define SWIGTYPE_p_Pythia8__LHArwgt swig_types[106]
3571 #define SWIGTYPE_p_Pythia8__LHAscales swig_types[107]
3572 #define SWIGTYPE_p_Pythia8__LHAup swig_types[108]
3573 #define SWIGTYPE_p_Pythia8__LHAupAlpgen swig_types[109]
3574 #define SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8 swig_types[110]
3575 #define SWIGTYPE_p_Pythia8__LHAupHelaconia swig_types[111]
3576 #define SWIGTYPE_p_Pythia8__LHAupLHEF swig_types[112]
3577 #define SWIGTYPE_p_Pythia8__LHAupMadgraph swig_types[113]
3578 #define SWIGTYPE_p_Pythia8__LHAweight swig_types[114]
3579 #define SWIGTYPE_p_Pythia8__LHAweightgroup swig_types[115]
3580 #define SWIGTYPE_p_Pythia8__LHAweights swig_types[116]
3581 #define SWIGTYPE_p_Pythia8__LHAwgt swig_types[117]
3582 #define SWIGTYPE_p_Pythia8__LHEF3FromPythia8 swig_types[118]
3583 #define SWIGTYPE_p_Pythia8__LHblockT_double_t swig_types[119]
3584 #define SWIGTYPE_p_Pythia8__LHblockT_int_t swig_types[120]
3585 #define SWIGTYPE_p_Pythia8__LHblockT_std__string_t swig_types[121]
3586 #define SWIGTYPE_p_Pythia8__LHdecayChannel swig_types[122]
3587 #define SWIGTYPE_p_Pythia8__LHdecayTable swig_types[123]
3588 #define SWIGTYPE_p_Pythia8__LHgenericBlock swig_types[124]
3589 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t swig_types[125]
3590 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t swig_types[126]
3591 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t swig_types[127]
3592 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t swig_types[128]
3593 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t swig_types[129]
3594 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_7_t swig_types[130]
3595 #define SWIGTYPE_p_Pythia8__LHmatrixBlockT_8_t swig_types[131]
3596 #define SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t swig_types[132]
3597 #define SWIGTYPE_p_Pythia8__Lepton swig_types[133]
3598 #define SWIGTYPE_p_Pythia8__Lepton2gamma swig_types[134]
3599 #define SWIGTYPE_p_Pythia8__LeptonPoint swig_types[135]
3600 #define SWIGTYPE_p_Pythia8__LundFFAvg swig_types[136]
3601 #define SWIGTYPE_p_Pythia8__LundFFRaw swig_types[137]
3602 #define SWIGTYPE_p_Pythia8__MBReconUserHooks swig_types[138]
3603 #define SWIGTYPE_p_Pythia8__MSTWpdf swig_types[139]
3604 #define SWIGTYPE_p_Pythia8__MVec swig_types[140]
3605 #define SWIGTYPE_p_Pythia8__MadgraphPar swig_types[141]
3606 #define SWIGTYPE_p_Pythia8__Merging swig_types[142]
3607 #define SWIGTYPE_p_Pythia8__MergingHooks swig_types[143]
3608 #define SWIGTYPE_p_Pythia8__MiniStringFragmentation swig_types[144]
3609 #define SWIGTYPE_p_Pythia8__Mode swig_types[145]
3610 #define SWIGTYPE_p_Pythia8__MultiRadial swig_types[146]
3611 #define SWIGTYPE_p_Pythia8__MultipartonInteractions swig_types[147]
3612 #define SWIGTYPE_p_Pythia8__NNPDF swig_types[148]
3613 #define SWIGTYPE_p_Pythia8__NaiveSubCollisionModel swig_types[149]
3614 #define SWIGTYPE_p_Pythia8__NeutrinoPoint swig_types[150]
3615 #define SWIGTYPE_p_Pythia8__Nucleon swig_types[151]
3616 #define SWIGTYPE_p_Pythia8__NucleusModel swig_types[152]
3617 #define SWIGTYPE_p_Pythia8__OverlappingRopeDipole swig_types[153]
3618 #define SWIGTYPE_p_Pythia8__PDF swig_types[154]
3619 #define SWIGTYPE_p_Pythia8__PDF__PDFEnvelope swig_types[155]
3620 #define SWIGTYPE_p_Pythia8__PVec swig_types[156]
3621 #define SWIGTYPE_p_Pythia8__Parm swig_types[157]
3622 #define SWIGTYPE_p_Pythia8__Particle swig_types[158]
3623 #define SWIGTYPE_p_Pythia8__ParticleData swig_types[159]
3624 #define SWIGTYPE_p_Pythia8__ParticleDataEntry swig_types[160]
3625 #define SWIGTYPE_p_Pythia8__ParticleDecays swig_types[161]
3626 #define SWIGTYPE_p_Pythia8__PartonLevel swig_types[162]
3627 #define SWIGTYPE_p_Pythia8__PartonSystem swig_types[163]
3628 #define SWIGTYPE_p_Pythia8__PartonSystems swig_types[164]
3629 #define SWIGTYPE_p_Pythia8__PartonVertex swig_types[165]
3630 #define SWIGTYPE_p_Pythia8__PhaseSpace swig_types[166]
3631 #define SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy swig_types[167]
3632 #define SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive swig_types[168]
3633 #define SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic swig_types[169]
3634 #define SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive swig_types[170]
3635 #define SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz swig_types[171]
3636 #define SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive swig_types[172]
3637 #define SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl swig_types[173]
3638 #define SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl swig_types[174]
3639 #define SWIGTYPE_p_Pythia8__PhaseSpaceLHA swig_types[175]
3640 #define SWIGTYPE_p_Pythia8__PomFix swig_types[176]
3641 #define SWIGTYPE_p_Pythia8__PomH1FitAB swig_types[177]
3642 #define SWIGTYPE_p_Pythia8__PomH1Jets swig_types[178]
3643 #define SWIGTYPE_p_Pythia8__PomHISASD swig_types[179]
3644 #define SWIGTYPE_p_Pythia8__PowhegHooks swig_types[180]
3645 #define SWIGTYPE_p_Pythia8__PowhegProcs swig_types[181]
3646 #define SWIGTYPE_p_Pythia8__ProcessContainer swig_types[182]
3647 #define SWIGTYPE_p_Pythia8__ProcessLevel swig_types[183]
3648 #define SWIGTYPE_p_Pythia8__ProgressLog swig_types[184]
3649 #define SWIGTYPE_p_Pythia8__ProtonPoint swig_types[185]
3650 #define SWIGTYPE_p_Pythia8__Pythia swig_types[186]
3651 #define SWIGTYPE_p_Pythia8__RHadrons swig_types[187]
3652 #define SWIGTYPE_p_Pythia8__Reader swig_types[188]
3653 #define SWIGTYPE_p_Pythia8__ResolvedParton swig_types[189]
3654 #define SWIGTYPE_p_Pythia8__ResonanceCha swig_types[190]
3655 #define SWIGTYPE_p_Pythia8__ResonanceChaD swig_types[191]
3656 #define SWIGTYPE_p_Pythia8__ResonanceChar swig_types[192]
3657 #define SWIGTYPE_p_Pythia8__ResonanceDM2 swig_types[193]
3658 #define SWIGTYPE_p_Pythia8__ResonanceDecays swig_types[194]
3659 #define SWIGTYPE_p_Pythia8__ResonanceExcited swig_types[195]
3660 #define SWIGTYPE_p_Pythia8__ResonanceFour swig_types[196]
3661 #define SWIGTYPE_p_Pythia8__ResonanceGeneric swig_types[197]
3662 #define SWIGTYPE_p_Pythia8__ResonanceGluino swig_types[198]
3663 #define SWIGTYPE_p_Pythia8__ResonanceGmZ swig_types[199]
3664 #define SWIGTYPE_p_Pythia8__ResonanceGraviton swig_types[200]
3665 #define SWIGTYPE_p_Pythia8__ResonanceH swig_types[201]
3666 #define SWIGTYPE_p_Pythia8__ResonanceHchg swig_types[202]
3667 #define SWIGTYPE_p_Pythia8__ResonanceHchgchgLeft swig_types[203]
3668 #define SWIGTYPE_p_Pythia8__ResonanceHchgchgRight swig_types[204]
3669 #define SWIGTYPE_p_Pythia8__ResonanceKKgluon swig_types[205]
3670 #define SWIGTYPE_p_Pythia8__ResonanceLeptoquark swig_types[206]
3671 #define SWIGTYPE_p_Pythia8__ResonanceNeut swig_types[207]
3672 #define SWIGTYPE_p_Pythia8__ResonanceNuRight swig_types[208]
3673 #define SWIGTYPE_p_Pythia8__ResonanceRhorizontal swig_types[209]
3674 #define SWIGTYPE_p_Pythia8__ResonanceS swig_types[210]
3675 #define SWIGTYPE_p_Pythia8__ResonanceSl swig_types[211]
3676 #define SWIGTYPE_p_Pythia8__ResonanceSlepton swig_types[212]
3677 #define SWIGTYPE_p_Pythia8__ResonanceSquark swig_types[213]
3678 #define SWIGTYPE_p_Pythia8__ResonanceTop swig_types[214]
3679 #define SWIGTYPE_p_Pythia8__ResonanceW swig_types[215]
3680 #define SWIGTYPE_p_Pythia8__ResonanceWRight swig_types[216]
3681 #define SWIGTYPE_p_Pythia8__ResonanceWidths swig_types[217]
3682 #define SWIGTYPE_p_Pythia8__ResonanceWprime swig_types[218]
3683 #define SWIGTYPE_p_Pythia8__ResonanceZRight swig_types[219]
3684 #define SWIGTYPE_p_Pythia8__ResonanceZp swig_types[220]
3685 #define SWIGTYPE_p_Pythia8__ResonanceZprime swig_types[221]
3686 #define SWIGTYPE_p_Pythia8__Rndm swig_types[222]
3687 #define SWIGTYPE_p_Pythia8__RndmEngine swig_types[223]
3688 #define SWIGTYPE_p_Pythia8__RopeDipole swig_types[224]
3689 #define SWIGTYPE_p_Pythia8__RopeDipoleEnd swig_types[225]
3690 #define SWIGTYPE_p_Pythia8__RopeFragPars swig_types[226]
3691 #define SWIGTYPE_p_Pythia8__Ropewalk swig_types[227]
3692 #define SWIGTYPE_p_Pythia8__RotBstMatrix swig_types[228]
3693 #define SWIGTYPE_p_Pythia8__SLHAinterface swig_types[229]
3694 #define SWIGTYPE_p_Pythia8__SUSYResonanceWidths swig_types[230]
3695 #define SWIGTYPE_p_Pythia8__Settings swig_types[231]
3696 #define SWIGTYPE_p_Pythia8__SetupContainers swig_types[232]
3697 #define SWIGTYPE_p_Pythia8__Sigma0AB2AB swig_types[233]
3698 #define SWIGTYPE_p_Pythia8__Sigma0AB2AX swig_types[234]
3699 #define SWIGTYPE_p_Pythia8__Sigma0AB2AXB swig_types[235]
3700 #define SWIGTYPE_p_Pythia8__Sigma0AB2XB swig_types[236]
3701 #define SWIGTYPE_p_Pythia8__Sigma0AB2XX swig_types[237]
3702 #define SWIGTYPE_p_Pythia8__Sigma0Process swig_types[238]
3703 #define SWIGTYPE_p_Pythia8__Sigma0nonDiffractive swig_types[239]
3704 #define SWIGTYPE_p_Pythia8__Sigma1Process swig_types[240]
3705 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar swig_types[241]
3706 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2H swig_types[242]
3707 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg swig_types[243]
3708 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal swig_types[244]
3709 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2W swig_types[245]
3710 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight swig_types[246]
3711 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime swig_types[247]
3712 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight swig_types[248]
3713 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX swig_types[249]
3714 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv swig_types[250]
3715 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ swig_types[251]
3716 #define SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime swig_types[252]
3717 #define SWIGTYPE_p_Pythia8__Sigma1ffbarZprimeWprime swig_types[253]
3718 #define SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar swig_types[254]
3719 #define SWIGTYPE_p_Pythia8__Sigma1gg2H swig_types[255]
3720 #define SWIGTYPE_p_Pythia8__Sigma1gg2S2XX swig_types[256]
3721 #define SWIGTYPE_p_Pythia8__Sigma1gmgm2H swig_types[257]
3722 #define SWIGTYPE_p_Pythia8__Sigma1lgm2lStar swig_types[258]
3723 #define SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg swig_types[259]
3724 #define SWIGTYPE_p_Pythia8__Sigma1qg2qStar swig_types[260]
3725 #define SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark swig_types[261]
3726 #define SWIGTYPE_p_Pythia8__Sigma1qq2antisquark swig_types[262]
3727 #define SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar swig_types[263]
3728 #define SWIGTYPE_p_Pythia8__Sigma2Process swig_types[264]
3729 #define SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar swig_types[265]
3730 #define SWIGTYPE_p_Pythia8__Sigma2QCqq2qq swig_types[266]
3731 #define SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar swig_types[267]
3732 #define SWIGTYPE_p_Pythia8__Sigma2SUSY swig_types[268]
3733 #define SWIGTYPE_p_Pythia8__Sigma2ff2fftW swig_types[269]
3734 #define SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ swig_types[270]
3735 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12 swig_types[271]
3736 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ swig_types[272]
3737 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW swig_types[273]
3738 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2HW swig_types[274]
3739 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ swig_types[275]
3740 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12 swig_types[276]
3741 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg swig_types[277]
3742 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg swig_types[278]
3743 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ swig_types[279]
3744 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma swig_types[280]
3745 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma swig_types[281]
3746 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar swig_types[282]
3747 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar swig_types[283]
3748 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2WW swig_types[284]
3749 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm swig_types[285]
3750 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW swig_types[286]
3751 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH swig_types[287]
3752 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar swig_types[288]
3753 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW swig_types[289]
3754 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm swig_types[290]
3755 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ swig_types[291]
3756 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma swig_types[292]
3757 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm swig_types[293]
3758 #define SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ swig_types[294]
3759 #define SWIGTYPE_p_Pythia8__Sigma2ffbarWggm swig_types[295]
3760 #define SWIGTYPE_p_Pythia8__Sigma2ffbargmZWgmZW swig_types[296]
3761 #define SWIGTYPE_p_Pythia8__Sigma2ffbargmZggm swig_types[297]
3762 #define SWIGTYPE_p_Pythia8__Sigma2fgm2Wf swig_types[298]
3763 #define SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf swig_types[299]
3764 #define SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg swig_types[300]
3765 #define SWIGTYPE_p_Pythia8__Sigma2gg2Hglt swig_types[301]
3766 #define SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg swig_types[302]
3767 #define SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma swig_types[303]
3768 #define SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg swig_types[304]
3769 #define SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar swig_types[305]
3770 #define SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar swig_types[306]
3771 #define SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar swig_types[307]
3772 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar swig_types[308]
3773 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3DJ1g swig_types[309]
3774 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g swig_types[310]
3775 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11 swig_types[311]
3776 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g swig_types[312]
3777 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm swig_types[313]
3778 #define SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g swig_types[314]
3779 #define SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj swig_types[315]
3780 #define SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma swig_types[316]
3781 #define SWIGTYPE_p_Pythia8__Sigma2gg2gg swig_types[317]
3782 #define SWIGTYPE_p_Pythia8__Sigma2gg2ggamma swig_types[318]
3783 #define SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino swig_types[319]
3784 #define SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar swig_types[320]
3785 #define SWIGTYPE_p_Pythia8__Sigma2gg2qqbar swig_types[321]
3786 #define SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark swig_types[322]
3787 #define SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar swig_types[323]
3788 #define SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar swig_types[324]
3789 #define SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl swig_types[325]
3790 #define SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq swig_types[326]
3791 #define SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq swig_types[327]
3792 #define SWIGTYPE_p_Pythia8__Sigma2qg2Hq swig_types[328]
3793 #define SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt swig_types[329]
3794 #define SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq swig_types[330]
3795 #define SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg swig_types[331]
3796 #define SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl swig_types[332]
3797 #define SWIGTYPE_p_Pythia8__Sigma2qg2QQbar3PJ1q swig_types[333]
3798 #define SWIGTYPE_p_Pythia8__Sigma2qg2QQbarX8q swig_types[334]
3799 #define SWIGTYPE_p_Pythia8__Sigma2qg2Sq2XXj swig_types[335]
3800 #define SWIGTYPE_p_Pythia8__Sigma2qg2Wq swig_types[336]
3801 #define SWIGTYPE_p_Pythia8__Sigma2qg2Zpq2XXj swig_types[337]
3802 #define SWIGTYPE_p_Pythia8__Sigma2qg2charsquark swig_types[338]
3803 #define SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark swig_types[339]
3804 #define SWIGTYPE_p_Pythia8__Sigma2qg2gmZq swig_types[340]
3805 #define SWIGTYPE_p_Pythia8__Sigma2qg2qg swig_types[341]
3806 #define SWIGTYPE_p_Pythia8__Sigma2qg2qgamma swig_types[342]
3807 #define SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino swig_types[343]
3808 #define SWIGTYPE_p_Pythia8__Sigma2qgm2qg swig_types[344]
3809 #define SWIGTYPE_p_Pythia8__Sigma2qgm2qgm swig_types[345]
3810 #define SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq swig_types[346]
3811 #define SWIGTYPE_p_Pythia8__Sigma2qq2QqtW swig_types[347]
3812 #define SWIGTYPE_p_Pythia8__Sigma2qq2qStarq swig_types[348]
3813 #define SWIGTYPE_p_Pythia8__Sigma2qq2qq swig_types[349]
3814 #define SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark swig_types[350]
3815 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2DY swig_types[351]
3816 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg swig_types[352]
3817 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt swig_types[353]
3818 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg swig_types[354]
3819 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg swig_types[355]
3820 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew swig_types[356]
3821 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar swig_types[357]
3822 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar swig_types[358]
3823 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3PJ1g swig_types[359]
3824 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11 swig_types[360]
3825 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbarX8g swig_types[361]
3826 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg swig_types[362]
3827 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj swig_types[363]
3828 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2charchar swig_types[364]
3829 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2charchi0 swig_types[365]
3830 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino swig_types[366]
3831 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0 swig_types[367]
3832 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino swig_types[368]
3833 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2gg swig_types[369]
3834 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma swig_types[370]
3835 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino swig_types[371]
3836 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg swig_types[372]
3837 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar swig_types[373]
3838 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar swig_types[374]
3839 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar swig_types[375]
3840 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew swig_types[376]
3841 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton swig_types[377]
3842 #define SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark swig_types[378]
3843 #define SWIGTYPE_p_Pythia8__Sigma3Process swig_types[379]
3844 #define SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW swig_types[380]
3845 #define SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW swig_types[381]
3846 #define SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ swig_types[382]
3847 #define SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar swig_types[383]
3848 #define SWIGTYPE_p_Pythia8__Sigma3gg2ggg swig_types[384]
3849 #define SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg swig_types[385]
3850 #define SWIGTYPE_p_Pythia8__Sigma3qg2qgg swig_types[386]
3851 #define SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff swig_types[387]
3852 #define SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame swig_types[388]
3853 #define SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff swig_types[389]
3854 #define SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame swig_types[390]
3855 #define SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar swig_types[391]
3856 #define SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg swig_types[392]
3857 #define SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff swig_types[393]
3858 #define SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame swig_types[394]
3859 #define SWIGTYPE_p_Pythia8__SigmaABMST swig_types[395]
3860 #define SWIGTYPE_p_Pythia8__SigmaLHAProcess swig_types[396]
3861 #define SWIGTYPE_p_Pythia8__SigmaMBR swig_types[397]
3862 #define SWIGTYPE_p_Pythia8__SigmaMultiparton swig_types[398]
3863 #define SWIGTYPE_p_Pythia8__SigmaOniaSetup swig_types[399]
3864 #define SWIGTYPE_p_Pythia8__SigmaPartialWave swig_types[400]
3865 #define SWIGTYPE_p_Pythia8__SigmaProcess swig_types[401]
3866 #define SWIGTYPE_p_Pythia8__SigmaRPP swig_types[402]
3867 #define SWIGTYPE_p_Pythia8__SigmaSaSDL swig_types[403]
3868 #define SWIGTYPE_p_Pythia8__SigmaTotAux swig_types[404]
3869 #define SWIGTYPE_p_Pythia8__SigmaTotOwn swig_types[405]
3870 #define SWIGTYPE_p_Pythia8__SigmaTotal swig_types[406]
3871 #define SWIGTYPE_p_Pythia8__SimpleSpaceShower swig_types[407]
3872 #define SWIGTYPE_p_Pythia8__SimpleTimeShower swig_types[408]
3873 #define SWIGTYPE_p_Pythia8__SimpleWeakShowerMEs swig_types[409]
3874 #define SWIGTYPE_p_Pythia8__SingleCell swig_types[410]
3875 #define SWIGTYPE_p_Pythia8__SingleCellJet swig_types[411]
3876 #define SWIGTYPE_p_Pythia8__SingleClusterJet swig_types[412]
3877 #define SWIGTYPE_p_Pythia8__SingleSlowJet swig_types[413]
3878 #define SWIGTYPE_p_Pythia8__SlowJet swig_types[414]
3879 #define SWIGTYPE_p_Pythia8__SlowJetHook swig_types[415]
3880 #define SWIGTYPE_p_Pythia8__SpaceDipoleEnd swig_types[416]
3881 #define SWIGTYPE_p_Pythia8__SpaceShower swig_types[417]
3882 #define SWIGTYPE_p_Pythia8__Sphericity swig_types[418]
3883 #define SWIGTYPE_p_Pythia8__StauWidths swig_types[419]
3884 #define SWIGTYPE_p_Pythia8__StringEnd swig_types[420]
3885 #define SWIGTYPE_p_Pythia8__StringFlav swig_types[421]
3886 #define SWIGTYPE_p_Pythia8__StringFragmentation swig_types[422]
3887 #define SWIGTYPE_p_Pythia8__StringLength swig_types[423]
3888 #define SWIGTYPE_p_Pythia8__StringPT swig_types[424]
3889 #define SWIGTYPE_p_Pythia8__StringRegion swig_types[425]
3890 #define SWIGTYPE_p_Pythia8__StringSystem swig_types[426]
3891 #define SWIGTYPE_p_Pythia8__StringVertex swig_types[427]
3892 #define SWIGTYPE_p_Pythia8__StringZ swig_types[428]
3893 #define SWIGTYPE_p_Pythia8__SubCollision swig_types[429]
3894 #define SWIGTYPE_p_Pythia8__SubCollisionModel swig_types[430]
3895 #define SWIGTYPE_p_Pythia8__SubCollisionModel__SigEst swig_types[431]
3896 #define SWIGTYPE_p_Pythia8__SuppressSmallPT swig_types[432]
3897 #define SWIGTYPE_p_Pythia8__SusyLesHouches swig_types[433]
3898 #define SWIGTYPE_p_Pythia8__TauDecays swig_types[434]
3899 #define SWIGTYPE_p_Pythia8__Thrust swig_types[435]
3900 #define SWIGTYPE_p_Pythia8__TimeDipoleEnd swig_types[436]
3901 #define SWIGTYPE_p_Pythia8__TimeShower swig_types[437]
3902 #define SWIGTYPE_p_Pythia8__TopReconUserHooks swig_types[438]
3903 #define SWIGTYPE_p_Pythia8__TrialReconnection swig_types[439]
3904 #define SWIGTYPE_p_Pythia8__UserHooks swig_types[440]
3905 #define SWIGTYPE_p_Pythia8__UserHooksVector swig_types[441]
3906 #define SWIGTYPE_p_Pythia8__Vec4 swig_types[442]
3907 #define SWIGTYPE_p_Pythia8__WVec swig_types[443]
3908 #define SWIGTYPE_p_Pythia8__Wave4 swig_types[444]
3909 #define SWIGTYPE_p_Pythia8__WidthFunction swig_types[445]
3910 #define SWIGTYPE_p_Pythia8__WoodsSaxonModel swig_types[446]
3911 #define SWIGTYPE_p_Pythia8__Word swig_types[447]
3912 #define SWIGTYPE_p_Pythia8__Writer swig_types[448]
3913 #define SWIGTYPE_p_Pythia8__XMLTag swig_types[449]
3914 #define SWIGTYPE_p_Pythia8__amcnlo_unitarised_interface swig_types[450]
3915 #define SWIGTYPE_p_Pythia8__nPDF swig_types[451]
3916 #define SWIGTYPE_p_State swig_types[452]
3917 #define SWIGTYPE_p_a_3__std__complexT_double_t swig_types[453]
3918 #define SWIGTYPE_p_a_4__std__complexT_double_t swig_types[454]
3919 #define SWIGTYPE_p_a_6__std__complexT_double_t swig_types[455]
3920 #define SWIGTYPE_p_a_7__std__complexT_double_t swig_types[456]
3921 #define SWIGTYPE_p_a_8__double swig_types[457]
3922 #define SWIGTYPE_p_allocator_type swig_types[458]
3923 #define SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[459]
3924 #define SWIGTYPE_p_bool swig_types[460]
3925 #define SWIGTYPE_p_char swig_types[461]
3926 #define SWIGTYPE_p_char_type swig_types[462]
3927 #define SWIGTYPE_p_const_reference swig_types[463]
3928 #define SWIGTYPE_p_difference_type swig_types[464]
3929 #define SWIGTYPE_p_double swig_types[465]
3930 #define SWIGTYPE_p_f_enum_std__ios_base__event_r_std__ios_base_int__void swig_types[466]
3931 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t swig_types[467]
3932 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[468]
3933 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[469]
3934 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[470]
3935 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[471]
3936 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[472]
3937 #define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[473]
3938 #define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[474]
3939 #define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[475]
3940 #define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[476]
3941 #define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[477]
3942 #define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[478]
3943 #define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[479]
3944 #define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[480]
3945 #define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[481]
3946 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_t swig_types[482]
3947 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[483]
3948 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[484]
3949 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[485]
3950 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[486]
3951 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[487]
3952 #define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[488]
3953 #define SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base swig_types[489]
3954 #define SWIGTYPE_p_first_type swig_types[490]
3955 #define SWIGTYPE_p_float swig_types[491]
3956 #define SWIGTYPE_p_fmtflags swig_types[492]
3957 #define SWIGTYPE_p_ifstream swig_types[493]
3958 #define SWIGTYPE_p_int swig_types[494]
3959 #define SWIGTYPE_p_int_type swig_types[495]
3960 #define SWIGTYPE_p_iostate swig_types[496]
3961 #define SWIGTYPE_p_key_type swig_types[497]
3962 #define SWIGTYPE_p_long swig_types[498]
3963 #define SWIGTYPE_p_long_double swig_types[499]
3964 #define SWIGTYPE_p_long_long swig_types[500]
3965 #define SWIGTYPE_p_mapped_type swig_types[501]
3966 #define SWIGTYPE_p_off_type swig_types[502]
3967 #define SWIGTYPE_p_openmode swig_types[503]
3968 #define SWIGTYPE_p_p_PyObject swig_types[504]
3969 #define SWIGTYPE_p_p_Pythia8__ColourDipole swig_types[505]
3970 #define SWIGTYPE_p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[506]
3971 #define SWIGTYPE_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[507]
3972 #define SWIGTYPE_p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[508]
3973 #define SWIGTYPE_p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[509]
3974 #define SWIGTYPE_p_p_void swig_types[510]
3975 #define SWIGTYPE_p_pos_t swig_types[511]
3976 #define SWIGTYPE_p_pos_type swig_types[512]
3977 #define SWIGTYPE_p_reference swig_types[513]
3978 #define SWIGTYPE_p_second_type swig_types[514]
3979 #define SWIGTYPE_p_seekdir swig_types[515]
3980 #define SWIGTYPE_p_short swig_types[516]
3981 #define SWIGTYPE_p_size_t swig_types[517]
3982 #define SWIGTYPE_p_size_type swig_types[518]
3983 #define SWIGTYPE_p_state_type swig_types[519]
3984 #define SWIGTYPE_p_std__allocatorT_Pythia8__Clustering_t swig_types[520]
3985 #define SWIGTYPE_p_std__allocatorT_Pythia8__HelicityParticle_t swig_types[521]
3986 #define SWIGTYPE_p_std__allocatorT_Pythia8__ProcessContainer_p_t swig_types[522]
3987 #define SWIGTYPE_p_std__allocatorT_Pythia8__ResonanceWidths_p_t swig_types[523]
3988 #define SWIGTYPE_p_std__allocatorT_Pythia8__SigmaProcess_p_t swig_types[524]
3989 #define SWIGTYPE_p_std__allocatorT_Pythia8__Vec4_t swig_types[525]
3990 #define SWIGTYPE_p_std__allocatorT_bool_t swig_types[526]
3991 #define SWIGTYPE_p_std__allocatorT_double_t swig_types[527]
3992 #define SWIGTYPE_p_std__allocatorT_int_t swig_types[528]
3993 #define SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t swig_types[529]
3994 #define SWIGTYPE_p_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t swig_types[530]
3995 #define SWIGTYPE_p_std__allocatorT_std__pairT_int_const_int_t_t swig_types[531]
3996 #define SWIGTYPE_p_std__allocatorT_std__pairT_int_int_t_t swig_types[532]
3997 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t swig_types[533]
3998 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t swig_types[534]
3999 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t swig_types[535]
4000 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t swig_types[536]
4001 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t swig_types[537]
4002 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t swig_types[538]
4003 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t swig_types[539]
4004 #define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_std__string_t_t swig_types[540]
4005 #define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[541]
4006 #define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[542]
4007 #define SWIGTYPE_p_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t swig_types[543]
4008 #define SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t swig_types[544]
4009 #define SWIGTYPE_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[545]
4010 #define SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[546]
4011 #define SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[547]
4012 #define SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[548]
4013 #define SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[549]
4014 #define SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t swig_types[550]
4015 #define SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[551]
4016 #define SWIGTYPE_p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[552]
4017 #define SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[553]
4018 #define SWIGTYPE_p_std__complexT_double_t swig_types[554]
4019 #define SWIGTYPE_p_std__ifstream swig_types[555]
4020 #define SWIGTYPE_p_std__invalid_argument swig_types[556]
4021 #define SWIGTYPE_p_std__ios_base swig_types[557]
4022 #define SWIGTYPE_p_std__lessT_double_t swig_types[558]
4023 #define SWIGTYPE_p_std__lessT_int_t swig_types[559]
4024 #define SWIGTYPE_p_std__lessT_std__string_t swig_types[560]
4025 #define SWIGTYPE_p_std__locale swig_types[561]
4026 #define SWIGTYPE_p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t swig_types[562]
4027 #define SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t swig_types[563]
4028 #define SWIGTYPE_p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t swig_types[564]
4029 #define SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t swig_types[565]
4030 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t swig_types[566]
4031 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t swig_types[567]
4032 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t swig_types[568]
4033 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t swig_types[569]
4034 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t swig_types[570]
4035 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t swig_types[571]
4036 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t swig_types[572]
4037 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t swig_types[573]
4038 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t swig_types[574]
4039 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t swig_types[575]
4040 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__WVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__WVec_t_t_t swig_types[576]
4041 #define SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t swig_types[577]
4042 #define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[578]
4043 #define SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t swig_types[579]
4044 #define SWIGTYPE_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t swig_types[580]
4045 #define SWIGTYPE_p_std__ofstream swig_types[581]
4046 #define SWIGTYPE_p_std__pairT_Pythia8__RotBstMatrix_Pythia8__RotBstMatrix_t swig_types[582]
4047 #define SWIGTYPE_p_std__pairT_Pythia8__Vec4_Pythia8__Vec4_t swig_types[583]
4048 #define SWIGTYPE_p_std__pairT_double_double_t swig_types[584]
4049 #define SWIGTYPE_p_std__pairT_int_int_t swig_types[585]
4050 #define SWIGTYPE_p_std__pairT_long_long_t swig_types[586]
4051 #define SWIGTYPE_p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t swig_types[587]
4052 #define SWIGTYPE_p_std__string swig_types[588]
4053 #define SWIGTYPE_p_std__string__size_type swig_types[589]
4054 #define SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t swig_types[590]
4055 #define SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t swig_types[591]
4056 #define SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t swig_types[592]
4057 #define SWIGTYPE_p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t swig_types[593]
4058 #define SWIGTYPE_p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t swig_types[594]
4059 #define SWIGTYPE_p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t swig_types[595]
4060 #define SWIGTYPE_p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t swig_types[596]
4061 #define SWIGTYPE_p_std__vectorT_Pythia8__LHblockT_double_t_std__allocatorT_Pythia8__LHblockT_double_t_t_t swig_types[597]
4062 #define SWIGTYPE_p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t swig_types[598]
4063 #define SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t swig_types[599]
4064 #define SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t__iterator swig_types[600]
4065 #define SWIGTYPE_p_std__vectorT_Pythia8__PhaseSpace_p_std__allocatorT_Pythia8__PhaseSpace_p_t_t swig_types[601]
4066 #define SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t swig_types[602]
4067 #define SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t swig_types[603]
4068 #define SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t swig_types[604]
4069 #define SWIGTYPE_p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t swig_types[605]
4070 #define SWIGTYPE_p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t swig_types[606]
4071 #define SWIGTYPE_p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t swig_types[607]
4072 #define SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t swig_types[608]
4073 #define SWIGTYPE_p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t swig_types[609]
4074 #define SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t swig_types[610]
4075 #define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[611]
4076 #define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[612]
4077 #define SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t swig_types[613]
4078 #define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[614]
4079 #define SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t swig_types[615]
4080 #define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[616]
4081 #define SWIGTYPE_p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t swig_types[617]
4082 #define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[618]
4083 #define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[619]
4084 #define SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t swig_types[620]
4085 #define SWIGTYPE_p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t swig_types[621]
4086 #define SWIGTYPE_p_streamoff swig_types[622]
4087 #define SWIGTYPE_p_streampos swig_types[623]
4088 #define SWIGTYPE_p_stringstream swig_types[624]
4089 #define SWIGTYPE_p_swig__SwigPyIterator swig_types[625]
4090 #define SWIGTYPE_p_traits_type swig_types[626]
4091 #define SWIGTYPE_p_unsigned_int swig_types[627]
4092 #define SWIGTYPE_p_unsigned_long swig_types[628]
4093 #define SWIGTYPE_p_unsigned_long_long swig_types[629]
4094 #define SWIGTYPE_p_unsigned_short swig_types[630]
4095 #define SWIGTYPE_p_value_type swig_types[631]
4096 static swig_type_info *swig_types[633];
4097 static swig_module_info swig_module = {swig_types, 632, 0, 0, 0, 0};
4098 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
4099 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
4100 
4101 /* -------- TYPES TABLE (END) -------- */
4102 
4103 #if (PY_VERSION_HEX <= 0x02000000)
4104 # if !defined(SWIG_PYTHON_CLASSIC)
4105 # error "This python version requires swig to be run with the '-classic' option"
4106 # endif
4107 #endif
4108 
4109 /*-----------------------------------------------
4110  @(target):= _pythia8.so
4111  ------------------------------------------------*/
4112 #if PY_VERSION_HEX >= 0x03000000
4113 # define SWIG_init PyInit__pythia8
4114 
4115 #else
4116 # define SWIG_init init_pythia8
4117 
4118 #endif
4119 #define SWIG_name "_pythia8"
4120 
4121 #define SWIGVERSION 0x030008
4122 #define SWIG_VERSION SWIGVERSION
4123 
4124 
4125 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
4126 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
4127 
4128 
4129 #include <stdexcept>
4130 
4131 
4132 namespace swig {
4134  protected:
4135  PyObject *_obj;
4136 
4137  public:
4138  SwigPtr_PyObject() :_obj(0)
4139  {
4140  }
4141 
4142  SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
4143  {
4144  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4145  Py_XINCREF(_obj);
4146  SWIG_PYTHON_THREAD_END_BLOCK;
4147  }
4148 
4149  SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
4150  {
4151  if (initial_ref) {
4152  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4153  Py_XINCREF(_obj);
4154  SWIG_PYTHON_THREAD_END_BLOCK;
4155  }
4156  }
4157 
4158  SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
4159  {
4160  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4161  Py_XINCREF(item._obj);
4162  Py_XDECREF(_obj);
4163  _obj = item._obj;
4164  SWIG_PYTHON_THREAD_END_BLOCK;
4165  return *this;
4166  }
4167 
4168  ~SwigPtr_PyObject()
4169  {
4170  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4171  Py_XDECREF(_obj);
4172  SWIG_PYTHON_THREAD_END_BLOCK;
4173  }
4174 
4175  operator PyObject *() const
4176  {
4177  return _obj;
4178  }
4179 
4180  PyObject *operator->() const
4181  {
4182  return _obj;
4183  }
4184  };
4185 }
4186 
4187 
4188 namespace swig {
4190  SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
4191 
4192  SwigVar_PyObject & operator = (PyObject* obj)
4193  {
4194  Py_XDECREF(_obj);
4195  _obj = obj;
4196  return *this;
4197  }
4198  };
4199 }
4200 
4201 
4202 #include <cstddef>
4203 
4204 
4205 #include <string>
4206 
4207 
4208 #include <iostream>
4209 
4210 #if PY_VERSION_HEX >= 0x03020000
4211 # define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
4212 #else
4213 # define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
4214 #endif
4215 
4216 
4217 #include <stdexcept>
4218 
4219 
4220 #if defined(__GNUC__)
4221 # if __GNUC__ == 2 && __GNUC_MINOR <= 96
4222 # define SWIG_STD_NOMODERN_STL
4223 # endif
4224 #endif
4225 
4226 
4227 #include <stddef.h>
4228 
4229 
4230 namespace swig {
4232  };
4233 
4235  private:
4236  SwigPtr_PyObject _seq;
4237 
4238  protected:
4239  SwigPyIterator(PyObject *seq) : _seq(seq)
4240  {
4241  }
4242 
4243  public:
4244  virtual ~SwigPyIterator() {}
4245 
4246  // Access iterator method, required by Python
4247  virtual PyObject *value() const = 0;
4248 
4249  // Forward iterator method, required by Python
4250  virtual SwigPyIterator *incr(size_t n = 1) = 0;
4251 
4252  // Backward iterator method, very common in C++, but not required in Python
4253  virtual SwigPyIterator *decr(size_t /*n*/ = 1)
4254  {
4255  throw stop_iteration();
4256  }
4257 
4258  // Random access iterator methods, but not required in Python
4259  virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
4260  {
4261  throw std::invalid_argument("operation not supported");
4262  }
4263 
4264  virtual bool equal (const SwigPyIterator &/*x*/) const
4265  {
4266  throw std::invalid_argument("operation not supported");
4267  }
4268 
4269  // C++ common/needed methods
4270  virtual SwigPyIterator *copy() const = 0;
4271 
4272  PyObject *next()
4273  {
4274  SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
4275  PyObject *obj = value();
4276  incr();
4277  SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
4278  return obj;
4279  }
4280 
4281  /* Make an alias for Python 3.x */
4282  PyObject *__next__()
4283  {
4284  return next();
4285  }
4286 
4287  PyObject *previous()
4288  {
4289  SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
4290  decr();
4291  PyObject *obj = value();
4292  SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
4293  return obj;
4294  }
4295 
4296  SwigPyIterator *advance(ptrdiff_t n)
4297  {
4298  return (n > 0) ? incr(n) : decr(-n);
4299  }
4300 
4301  bool operator == (const SwigPyIterator& x) const
4302  {
4303  return equal(x);
4304  }
4305 
4306  bool operator != (const SwigPyIterator& x) const
4307  {
4308  return ! operator==(x);
4309  }
4310 
4311  SwigPyIterator& operator += (ptrdiff_t n)
4312  {
4313  return *advance(n);
4314  }
4315 
4316  SwigPyIterator& operator -= (ptrdiff_t n)
4317  {
4318  return *advance(-n);
4319  }
4320 
4321  SwigPyIterator* operator + (ptrdiff_t n) const
4322  {
4323  return copy()->advance(n);
4324  }
4325 
4326  SwigPyIterator* operator - (ptrdiff_t n) const
4327  {
4328  return copy()->advance(-n);
4329  }
4330 
4331  ptrdiff_t operator - (const SwigPyIterator& x) const
4332  {
4333  return x.distance(*this);
4334  }
4335 
4336  static swig_type_info* descriptor() {
4337  static int init = 0;
4338  static swig_type_info* desc = 0;
4339  if (!init) {
4340  desc = SWIG_TypeQuery("swig::SwigPyIterator *");
4341  init = 1;
4342  }
4343  return desc;
4344  }
4345  };
4346 
4347 #if defined(SWIGPYTHON_BUILTIN)
4348  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
4349  {
4350  Py_INCREF(pyself);
4351  return pyself;
4352  }
4353 #endif
4354 }
4355 
4356 
4357 SWIGINTERN int
4358 SWIG_AsVal_double (PyObject *obj, double *val)
4359 {
4360  int res = SWIG_TypeError;
4361  if (PyFloat_Check(obj)) {
4362  if (val) *val = PyFloat_AsDouble(obj);
4363  return SWIG_OK;
4364 #if PY_VERSION_HEX < 0x03000000
4365  } else if (PyInt_Check(obj)) {
4366  if (val) *val = PyInt_AsLong(obj);
4367  return SWIG_OK;
4368 #endif
4369  } else if (PyLong_Check(obj)) {
4370  double v = PyLong_AsDouble(obj);
4371  if (!PyErr_Occurred()) {
4372  if (val) *val = v;
4373  return SWIG_OK;
4374  } else {
4375  PyErr_Clear();
4376  }
4377  }
4378 #ifdef SWIG_PYTHON_CAST_MODE
4379  {
4380  int dispatch = 0;
4381  double d = PyFloat_AsDouble(obj);
4382  if (!PyErr_Occurred()) {
4383  if (val) *val = d;
4384  return SWIG_AddCast(SWIG_OK);
4385  } else {
4386  PyErr_Clear();
4387  }
4388  if (!dispatch) {
4389  long v = PyLong_AsLong(obj);
4390  if (!PyErr_Occurred()) {
4391  if (val) *val = v;
4392  return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
4393  } else {
4394  PyErr_Clear();
4395  }
4396  }
4397  }
4398 #endif
4399  return res;
4400 }
4401 
4402 
4403 #include <float.h>
4404 
4405 
4406 #include <math.h>
4407 
4408 
4409 SWIGINTERNINLINE int
4410 SWIG_CanCastAsInteger(double *d, double min, double max) {
4411  double x = *d;
4412  if ((min <= x && x <= max)) {
4413  double fx = floor(x);
4414  double cx = ceil(x);
4415  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
4416  if ((errno == EDOM) || (errno == ERANGE)) {
4417  errno = 0;
4418  } else {
4419  double summ, reps, diff;
4420  if (rd < x) {
4421  diff = x - rd;
4422  } else if (rd > x) {
4423  diff = rd - x;
4424  } else {
4425  return 1;
4426  }
4427  summ = rd + x;
4428  reps = diff/summ;
4429  if (reps < 8*DBL_EPSILON) {
4430  *d = rd;
4431  return 1;
4432  }
4433  }
4434  }
4435  return 0;
4436 }
4437 
4438 
4439 SWIGINTERN int
4440 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
4441 {
4442 #if PY_VERSION_HEX < 0x03000000
4443  if (PyInt_Check(obj)) {
4444  long v = PyInt_AsLong(obj);
4445  if (v >= 0) {
4446  if (val) *val = v;
4447  return SWIG_OK;
4448  } else {
4449  return SWIG_OverflowError;
4450  }
4451  } else
4452 #endif
4453  if (PyLong_Check(obj)) {
4454  unsigned long v = PyLong_AsUnsignedLong(obj);
4455  if (!PyErr_Occurred()) {
4456  if (val) *val = v;
4457  return SWIG_OK;
4458  } else {
4459  PyErr_Clear();
4460  return SWIG_OverflowError;
4461  }
4462  }
4463 #ifdef SWIG_PYTHON_CAST_MODE
4464  {
4465  int dispatch = 0;
4466  unsigned long v = PyLong_AsUnsignedLong(obj);
4467  if (!PyErr_Occurred()) {
4468  if (val) *val = v;
4469  return SWIG_AddCast(SWIG_OK);
4470  } else {
4471  PyErr_Clear();
4472  }
4473  if (!dispatch) {
4474  double d;
4475  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
4476  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
4477  if (val) *val = (unsigned long)(d);
4478  return res;
4479  }
4480  }
4481  }
4482 #endif
4483  return SWIG_TypeError;
4484 }
4485 
4486 
4487 SWIGINTERNINLINE int
4488 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
4489 {
4490  unsigned long v;
4491  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
4492  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
4493  return res;
4494 }
4495 
4496 
4497  #define SWIG_From_long PyLong_FromLong
4498 
4499 
4500 SWIGINTERNINLINE PyObject *
4501 SWIG_From_ptrdiff_t (ptrdiff_t value)
4502 {
4503  return SWIG_From_long (static_cast< long >(value));
4504 }
4505 
4506 
4507 SWIGINTERNINLINE PyObject*
4508  SWIG_From_bool (bool value)
4509 {
4510  return PyBool_FromLong(value ? 1 : 0);
4511 }
4512 
4513 
4514 SWIGINTERN int
4515 SWIG_AsVal_long (PyObject *obj, long* val)
4516 {
4517 #if PY_VERSION_HEX < 0x03000000
4518  if (PyInt_Check(obj)) {
4519  if (val) *val = PyInt_AsLong(obj);
4520  return SWIG_OK;
4521  } else
4522 #endif
4523  if (PyLong_Check(obj)) {
4524  long v = PyLong_AsLong(obj);
4525  if (!PyErr_Occurred()) {
4526  if (val) *val = v;
4527  return SWIG_OK;
4528  } else {
4529  PyErr_Clear();
4530  return SWIG_OverflowError;
4531  }
4532  }
4533 #ifdef SWIG_PYTHON_CAST_MODE
4534  {
4535  int dispatch = 0;
4536  long v = PyInt_AsLong(obj);
4537  if (!PyErr_Occurred()) {
4538  if (val) *val = v;
4539  return SWIG_AddCast(SWIG_OK);
4540  } else {
4541  PyErr_Clear();
4542  }
4543  if (!dispatch) {
4544  double d;
4545  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
4546  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
4547  if (val) *val = (long)(d);
4548  return res;
4549  }
4550  }
4551  }
4552 #endif
4553  return SWIG_TypeError;
4554 }
4555 
4556 
4557 SWIGINTERNINLINE int
4558 SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
4559 {
4560  long v;
4561  int res = SWIG_AsVal_long (obj, val ? &v : 0);
4562  if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
4563  return res;
4564 }
4565 
4566 
4567 #include <algorithm>
4568 
4569 
4570 #include <vector>
4571 
4572 
4573 #include <utility>
4574 
4575 
4576 #include <map>
4577 
4578 
4579 #include <algorithm>
4580 
4581 
4582 #include <deque>
4583 
4584 
4585 #include <set>
4586 
4587 
4588 #include <list>
4589 
4590 
4591 #ifndef SWIG_STD_NOMODERN_STL
4592 # include <ios>
4593 #else
4594 # include <streambuf.h>
4595 #endif
4596 
4597 
4598 SWIGINTERNINLINE PyObject*
4599  SWIG_From_int (int value)
4600 {
4601  return PyInt_FromLong((long) value);
4602 }
4603 
4604 
4605 #include <limits.h>
4606 #if !defined(SWIG_NO_LLONG_MAX)
4607 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
4608 # define LLONG_MAX __LONG_LONG_MAX__
4609 # define LLONG_MIN (-LLONG_MAX - 1LL)
4610 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
4611 # endif
4612 #endif
4613 
4614 
4615 SWIGINTERN int
4616 SWIG_AsVal_int (PyObject * obj, int *val)
4617 {
4618  long v;
4619  int res = SWIG_AsVal_long (obj, &v);
4620  if (SWIG_IsOK(res)) {
4621  if ((v < INT_MIN || v > INT_MAX)) {
4622  return SWIG_OverflowError;
4623  } else {
4624  if (val) *val = static_cast< int >(v);
4625  }
4626  }
4627  return res;
4628 }
4629 
4630 
4631 SWIGINTERNINLINE PyObject*
4632 SWIG_From_unsigned_SS_long (unsigned long value)
4633 {
4634  return (value > LONG_MAX) ?
4635  PyLong_FromUnsignedLong(value) : PyLong_FromLong(static_cast< long >(value));
4636 }
4637 
4638 
4639 SWIGINTERNINLINE PyObject *
4640 SWIG_From_size_t (size_t value)
4641 {
4642  return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
4643 }
4644 
4645 
4646 SWIGINTERN int
4647 SWIG_AsVal_bool (PyObject *obj, bool *val)
4648 {
4649  int r;
4650  if (!PyBool_Check(obj))
4651  return SWIG_ERROR;
4652  r = PyObject_IsTrue(obj);
4653  if (r == -1)
4654  return SWIG_ERROR;
4655  if (val) *val = r ? true : false;
4656  return SWIG_OK;
4657 }
4658 
4659 
4660 SWIGINTERN swig_type_info*
4661 SWIG_pchar_descriptor(void)
4662 {
4663  static int init = 0;
4664  static swig_type_info* info = 0;
4665  if (!init) {
4666  info = SWIG_TypeQuery("_p_char");
4667  init = 1;
4668  }
4669  return info;
4670 }
4671 
4672 
4673 SWIGINTERNINLINE PyObject *
4674 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
4675 {
4676  if (carray) {
4677  if (size > INT_MAX) {
4678  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4679  return pchar_descriptor ?
4680  SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
4681  } else {
4682 #if PY_VERSION_HEX >= 0x03000000
4683 #if PY_VERSION_HEX >= 0x03010000
4684  return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
4685 #else
4686  return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
4687 #endif
4688 #else
4689  return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
4690 #endif
4691  }
4692  } else {
4693  return SWIG_Py_Void();
4694  }
4695 }
4696 
4697 
4698 SWIGINTERNINLINE PyObject *
4699 SWIG_From_char (char c)
4700 {
4701  return SWIG_FromCharPtrAndSize(&c,1);
4702 }
4703 
4704 
4705 SWIGINTERN int
4706 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
4707 {
4708 #if PY_VERSION_HEX>=0x03000000
4709  if (PyUnicode_Check(obj))
4710 #else
4711  if (PyString_Check(obj))
4712 #endif
4713  {
4714  char *cstr; Py_ssize_t len;
4715 #if PY_VERSION_HEX>=0x03000000
4716  if (!alloc && cptr) {
4717  /* We can't allow converting without allocation, since the internal
4718  representation of string in Python 3 is UCS-2/UCS-4 but we require
4719  a UTF-8 representation.
4720  TODO(bhy) More detailed explanation */
4721  return SWIG_RuntimeError;
4722  }
4723  obj = PyUnicode_AsUTF8String(obj);
4724  PyBytes_AsStringAndSize(obj, &cstr, &len);
4725  if(alloc) *alloc = SWIG_NEWOBJ;
4726 #else
4727  PyString_AsStringAndSize(obj, &cstr, &len);
4728 #endif
4729  if (cptr) {
4730  if (alloc) {
4731  /*
4732  In python the user should not be able to modify the inner
4733  string representation. To warranty that, if you define
4734  SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
4735  buffer is always returned.
4736 
4737  The default behavior is just to return the pointer value,
4738  so, be careful.
4739  */
4740 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
4741  if (*alloc != SWIG_OLDOBJ)
4742 #else
4743  if (*alloc == SWIG_NEWOBJ)
4744 #endif
4745  {
4746  *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
4747  *alloc = SWIG_NEWOBJ;
4748  } else {
4749  *cptr = cstr;
4750  *alloc = SWIG_OLDOBJ;
4751  }
4752  } else {
4753  #if PY_VERSION_HEX>=0x03000000
4754  assert(0); /* Should never reach here in Python 3 */
4755  #endif
4756  *cptr = SWIG_Python_str_AsChar(obj);
4757  }
4758  }
4759  if (psize) *psize = len + 1;
4760 #if PY_VERSION_HEX>=0x03000000
4761  Py_XDECREF(obj);
4762 #endif
4763  return SWIG_OK;
4764  } else {
4765 #if defined(SWIG_PYTHON_2_UNICODE)
4766 #if PY_VERSION_HEX<0x03000000
4767  if (PyUnicode_Check(obj)) {
4768  char *cstr; Py_ssize_t len;
4769  if (!alloc && cptr) {
4770  return SWIG_RuntimeError;
4771  }
4772  obj = PyUnicode_AsUTF8String(obj);
4773  if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
4774  if (cptr) {
4775  if (alloc) *alloc = SWIG_NEWOBJ;
4776  *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
4777  }
4778  if (psize) *psize = len + 1;
4779 
4780  Py_XDECREF(obj);
4781  return SWIG_OK;
4782  } else {
4783  Py_XDECREF(obj);
4784  }
4785  }
4786 #endif
4787 #endif
4788 
4789  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
4790  if (pchar_descriptor) {
4791  void* vptr = 0;
4792  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
4793  if (cptr) *cptr = (char *) vptr;
4794  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
4795  if (alloc) *alloc = SWIG_OLDOBJ;
4796  return SWIG_OK;
4797  }
4798  }
4799  }
4800  return SWIG_TypeError;
4801 }
4802 
4803 
4804 SWIGINTERN int
4805 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
4806 {
4807  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
4808  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
4809  if (SWIG_IsOK(res)) {
4810  /* special case of single char conversion when we don't need space for NUL */
4811  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
4812  if (csize <= size) {
4813  if (val) {
4814  if (csize) memcpy(val, cptr, csize*sizeof(char));
4815  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
4816  }
4817  if (alloc == SWIG_NEWOBJ) {
4818  delete[] cptr;
4819  res = SWIG_DelNewMask(res);
4820  }
4821  return res;
4822  }
4823  if (alloc == SWIG_NEWOBJ) delete[] cptr;
4824  }
4825  return SWIG_TypeError;
4826 }
4827 
4828 
4829 SWIGINTERN int
4830 SWIG_AsVal_char (PyObject * obj, char *val)
4831 {
4832  int res = SWIG_AsCharArray(obj, val, 1);
4833  if (!SWIG_IsOK(res)) {
4834  long v;
4835  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
4836  if (SWIG_IsOK(res)) {
4837  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
4838  if (val) *val = static_cast< char >(v);
4839  } else {
4840  res = SWIG_OverflowError;
4841  }
4842  }
4843  }
4844  return res;
4845 }
4846 
4847 
4848 #include <iostream>
4849 
4850 
4851 SWIGINTERN int
4852 SWIG_AsVal_short (PyObject * obj, short *val)
4853 {
4854  long v;
4855  int res = SWIG_AsVal_long (obj, &v);
4856  if (SWIG_IsOK(res)) {
4857  if ((v < SHRT_MIN || v > SHRT_MAX)) {
4858  return SWIG_OverflowError;
4859  } else {
4860  if (val) *val = static_cast< short >(v);
4861  }
4862  }
4863  return res;
4864 }
4865 
4866 
4867 SWIGINTERN int
4868 SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
4869 {
4870  unsigned long v;
4871  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
4872  if (SWIG_IsOK(res)) {
4873  if ((v > USHRT_MAX)) {
4874  return SWIG_OverflowError;
4875  } else {
4876  if (val) *val = static_cast< unsigned short >(v);
4877  }
4878  }
4879  return res;
4880 }
4881 
4882 
4883 SWIGINTERN int
4884 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
4885 {
4886  unsigned long v;
4887  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
4888  if (SWIG_IsOK(res)) {
4889  if ((v > UINT_MAX)) {
4890  return SWIG_OverflowError;
4891  } else {
4892  if (val) *val = static_cast< unsigned int >(v);
4893  }
4894  }
4895  return res;
4896 }
4897 
4898 
4899 SWIGINTERN int
4900 SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
4901 {
4902  int res = SWIG_TypeError;
4903  if (PyLong_Check(obj)) {
4904  long long v = PyLong_AsLongLong(obj);
4905  if (!PyErr_Occurred()) {
4906  if (val) *val = v;
4907  return SWIG_OK;
4908  } else {
4909  PyErr_Clear();
4910  res = SWIG_OverflowError;
4911  }
4912  } else {
4913  long v;
4914  res = SWIG_AsVal_long (obj,&v);
4915  if (SWIG_IsOK(res)) {
4916  if (val) *val = v;
4917  return res;
4918  }
4919  }
4920 #ifdef SWIG_PYTHON_CAST_MODE
4921  {
4922  const double mant_max = 1LL << DBL_MANT_DIG;
4923  const double mant_min = -mant_max;
4924  double d;
4925  res = SWIG_AsVal_double (obj,&d);
4926  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
4927  if (val) *val = (long long)(d);
4928  return SWIG_AddCast(res);
4929  }
4930  res = SWIG_TypeError;
4931  }
4932 #endif
4933  return res;
4934 }
4935 
4936 
4937 SWIGINTERN int
4938 SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
4939 {
4940  int res = SWIG_TypeError;
4941  if (PyLong_Check(obj)) {
4942  unsigned long long v = PyLong_AsUnsignedLongLong(obj);
4943  if (!PyErr_Occurred()) {
4944  if (val) *val = v;
4945  return SWIG_OK;
4946  } else {
4947  PyErr_Clear();
4948  res = SWIG_OverflowError;
4949  }
4950  } else {
4951  unsigned long v;
4952  res = SWIG_AsVal_unsigned_SS_long (obj,&v);
4953  if (SWIG_IsOK(res)) {
4954  if (val) *val = v;
4955  return res;
4956  }
4957  }
4958 #ifdef SWIG_PYTHON_CAST_MODE
4959  {
4960  const double mant_max = 1LL << DBL_MANT_DIG;
4961  double d;
4962  res = SWIG_AsVal_double (obj,&d);
4963  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
4964  if (val) *val = (unsigned long long)(d);
4965  return SWIG_AddCast(res);
4966  }
4967  res = SWIG_TypeError;
4968  }
4969 #endif
4970  return res;
4971 }
4972 
4973 
4974 /* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
4975 #ifndef SWIG_isfinite
4976 # if defined(isfinite)
4977 # define SWIG_isfinite(X) (isfinite(X))
4978 # elif defined(_MSC_VER)
4979 # define SWIG_isfinite(X) (_finite(X))
4980 # elif defined(__sun) && defined(__SVR4)
4981 # include <ieeefp.h>
4982 # define SWIG_isfinite(X) (finite(X))
4983 # endif
4984 #endif
4985 
4986 
4987 /* Accept infinite as a valid float value unless we are unable to check if a value is finite */
4988 #ifdef SWIG_isfinite
4989 # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
4990 #else
4991 # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
4992 #endif
4993 
4994 
4995 SWIGINTERN int
4996 SWIG_AsVal_float (PyObject * obj, float *val)
4997 {
4998  double v;
4999  int res = SWIG_AsVal_double (obj, &v);
5000  if (SWIG_IsOK(res)) {
5001  if (SWIG_Float_Overflow_Check(v)) {
5002  return SWIG_OverflowError;
5003  } else {
5004  if (val) *val = static_cast< float >(v);
5005  }
5006  }
5007  return res;
5008 }
5009 
5010 SWIGINTERN std::basic_ostream< char,std::char_traits< char > > &std_basic_ostream_Sl_char_Sg__operator_Sl__Sl___SWIG_17(std::basic_ostream< char > *self,std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &s){
5011  *self << s;
5012  return *self;
5013  }
5014 
5015 
5016 
5017 
5018 #ifndef SWIG_STD_NOMODERN_STL
5019 #include <streambuf>
5020 #else
5021 #include <streambuf.h>
5022 #endif
5023 
5024 
5025 #include <sstream>
5026 
5027 
5028 #include <complex>
5029 
5030 
5031 namespace swig {
5032  template <class Type>
5034  typedef Type noconst_type;
5035  };
5036 
5037  template <class Type>
5038  struct noconst_traits<const Type> {
5039  typedef Type noconst_type;
5040  };
5041 
5042  /*
5043  type categories
5044  */
5045  struct pointer_category { };
5046  struct value_category { };
5047 
5048  /*
5049  General traits that provides type_name and type_info
5050  */
5051  template <class Type> struct traits { };
5052 
5053  template <class Type>
5054  inline const char* type_name() {
5056  }
5057 
5058  template <class Type>
5059  struct traits_info {
5060  static swig_type_info *type_query(std::string name) {
5061  name += " *";
5062  return SWIG_TypeQuery(name.c_str());
5063  }
5064  static swig_type_info *type_info() {
5065  static swig_type_info *info = type_query(type_name<Type>());
5066  return info;
5067  }
5068  };
5069 
5070  template <class Type>
5071  inline swig_type_info *type_info() {
5073  }
5074 
5075  /*
5076  Partial specialization for pointers
5077  */
5078  template <class Type> struct traits <Type *> {
5079  typedef pointer_category category;
5080  static std::string make_ptr_name(const char* name) {
5081  std::string ptrname = name;
5082  ptrname += " *";
5083  return ptrname;
5084  }
5085  static const char* type_name() {
5086  static std::string name = make_ptr_name(swig::type_name<Type>());
5087  return name.c_str();
5088  }
5089  };
5090 
5091  template <class Type, class Category>
5092  struct traits_as { };
5093 
5094  template <class Type, class Category>
5095  struct traits_check { };
5096 
5097 }
5098 
5099 
5100 namespace swig {
5101  /*
5102  Traits that provides the from method
5103  */
5104  template <class Type> struct traits_from_ptr {
5105  static PyObject *from(Type *val, int owner = 0) {
5106  return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
5107  }
5108  };
5109 
5110  template <class Type> struct traits_from {
5111  static PyObject *from(const Type& val) {
5112  return traits_from_ptr<Type>::from(new Type(val), 1);
5113  }
5114  };
5115 
5116  template <class Type> struct traits_from<Type *> {
5117  static PyObject *from(Type* val) {
5118  return traits_from_ptr<Type>::from(val, 0);
5119  }
5120  };
5121 
5122  template <class Type> struct traits_from<const Type *> {
5123  static PyObject *from(const Type* val) {
5124  return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
5125  }
5126  };
5127 
5128 
5129  template <class Type>
5130  inline PyObject *from(const Type& val) {
5131  return traits_from<Type>::from(val);
5132  }
5133 
5134  template <class Type>
5135  inline PyObject *from_ptr(Type* val, int owner) {
5136  return traits_from_ptr<Type>::from(val, owner);
5137  }
5138 
5139  /*
5140  Traits that provides the asval/as/check method
5141  */
5142  template <class Type>
5143  struct traits_asptr {
5144  static int asptr(PyObject *obj, Type **val) {
5145  Type *p;
5146  int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
5147  if (SWIG_IsOK(res)) {
5148  if (val) *val = p;
5149  }
5150  return res;
5151  }
5152  };
5153 
5154  template <class Type>
5155  inline int asptr(PyObject *obj, Type **vptr) {
5156  return traits_asptr<Type>::asptr(obj, vptr);
5157  }
5158 
5159  template <class Type>
5160  struct traits_asval {
5161  static int asval(PyObject *obj, Type *val) {
5162  if (val) {
5163  Type *p = 0;
5164  int res = traits_asptr<Type>::asptr(obj, &p);
5165  if (!SWIG_IsOK(res)) return res;
5166  if (p) {
5167  typedef typename noconst_traits<Type>::noconst_type noconst_type;
5168  *(const_cast<noconst_type*>(val)) = *p;
5169  if (SWIG_IsNewObj(res)){
5170  delete p;
5171  res = SWIG_DelNewMask(res);
5172  }
5173  return res;
5174  } else {
5175  return SWIG_ERROR;
5176  }
5177  } else {
5178  return traits_asptr<Type>::asptr(obj, (Type **)(0));
5179  }
5180  }
5181  };
5182 
5183  template <class Type> struct traits_asval<Type*> {
5184  static int asval(PyObject *obj, Type **val) {
5185  if (val) {
5186  typedef typename noconst_traits<Type>::noconst_type noconst_type;
5187  noconst_type *p = 0;
5188  int res = traits_asptr<noconst_type>::asptr(obj, &p);
5189  if (SWIG_IsOK(res)) {
5190  *(const_cast<noconst_type**>(val)) = p;
5191  }
5192  return res;
5193  } else {
5194  return traits_asptr<Type>::asptr(obj, (Type **)(0));
5195  }
5196  }
5197  };
5198 
5199  template <class Type>
5200  inline int asval(PyObject *obj, Type *val) {
5201  return traits_asval<Type>::asval(obj, val);
5202  }
5203 
5204  template <class Type>
5205  struct traits_as<Type, value_category> {
5206  static Type as(PyObject *obj, bool throw_error) {
5207  Type v;
5208  int res = asval(obj, &v);
5209  if (!obj || !SWIG_IsOK(res)) {
5210  if (!PyErr_Occurred()) {
5211  ::SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
5212  }
5213  if (throw_error) throw std::invalid_argument("bad type");
5214  }
5215  return v;
5216  }
5217  };
5218 
5219  template <class Type>
5220  struct traits_as<Type, pointer_category> {
5221  static Type as(PyObject *obj, bool throw_error) {
5222  Type *v = 0;
5223  int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
5224  if (SWIG_IsOK(res) && v) {
5225  if (SWIG_IsNewObj(res)) {
5226  Type r(*v);
5227  delete v;
5228  return r;
5229  } else {
5230  return *v;
5231  }
5232  } else {
5233  // Uninitialized return value, no Type() constructor required.
5234  static Type *v_def = (Type*) malloc(sizeof(Type));
5235  if (!PyErr_Occurred()) {
5236  SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
5237  }
5238  if (throw_error) throw std::invalid_argument("bad type");
5239  memset(v_def,0,sizeof(Type));
5240  return *v_def;
5241  }
5242  }
5243  };
5244 
5245  template <class Type>
5246  struct traits_as<Type*, pointer_category> {
5247  static Type* as(PyObject *obj, bool throw_error) {
5248  Type *v = 0;
5249  int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
5250  if (SWIG_IsOK(res)) {
5251  return v;
5252  } else {
5253  if (!PyErr_Occurred()) {
5254  SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
5255  }
5256  if (throw_error) throw std::invalid_argument("bad type");
5257  return 0;
5258  }
5259  }
5260  };
5261 
5262  template <class Type>
5263  inline Type as(PyObject *obj, bool te = false) {
5265  }
5266 
5267  template <class Type>
5269  static bool check(PyObject *obj) {
5270  int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
5271  return SWIG_IsOK(res) ? true : false;
5272  }
5273  };
5274 
5275  template <class Type>
5277  static bool check(PyObject *obj) {
5278  int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
5279  return SWIG_IsOK(res) ? true : false;
5280  }
5281  };
5282 
5283  template <class Type>
5284  inline bool check(PyObject *obj) {
5286  }
5287 }
5288 
5289 
5290 namespace swig {
5291  template <> struct traits< int > {
5292  typedef value_category category;
5293  static const char* type_name() { return"int"; }
5294  };
5295  template <> struct traits_asval< int > {
5296  typedef int value_type;
5297  static int asval(PyObject *obj, value_type *val) {
5298  return SWIG_AsVal_int (obj, val);
5299  }
5300  };
5301  template <> struct traits_from< int > {
5302  typedef int value_type;
5303  static PyObject *from(const value_type& val) {
5304  return SWIG_From_int (val);
5305  }
5306  };
5307 }
5308 
5309 
5310  namespace swig {
5311 
5312 
5313 
5314 
5315 
5316 
5317 
5318 
5319 
5320 
5321 
5322 
5323 
5324 
5325 
5326 
5327 
5328 
5329 
5330 
5331 
5332 
5333 
5334 
5335 
5336 
5337 
5338 
5339 
5340 
5341 
5342 
5343 
5344 
5345 
5346 
5347 
5348 
5349 
5350 
5351 
5352 
5353 
5354 
5355 
5356 
5357 
5358 
5359 
5360  template <class T, class U >
5361  struct traits_asptr<std::pair<T,U> > {
5362  typedef std::pair<T,U> value_type;
5363 
5364  static int get_pair(PyObject* first, PyObject* second,
5365  std::pair<T,U> **val)
5366  {
5367  if (val) {
5368  value_type *vp = (new std::pair<T,U>);
5369  T *pfirst = &(vp->first);
5370  int res1 = swig::asval((PyObject*)first, pfirst);
5371  if (!SWIG_IsOK(res1)) return res1;
5372  U *psecond = &(vp->second);
5373  int res2 = swig::asval((PyObject*)second, psecond);
5374  if (!SWIG_IsOK(res2)) return res2;
5375  *val = vp;
5376  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
5377  } else {
5378  T *pfirst = 0;
5379  int res1 = swig::asval((PyObject*)first, pfirst);
5380  if (!SWIG_IsOK(res1)) return res1;
5381  U *psecond = 0;
5382  int res2 = swig::asval((PyObject*)second, psecond);
5383  if (!SWIG_IsOK(res2)) return res2;
5384  return res1 > res2 ? res1 : res2;
5385  }
5386  }
5387 
5388  static int asptr(PyObject *obj, std::pair<T,U> **val) {
5389  int res = SWIG_ERROR;
5390  if (PyTuple_Check(obj)) {
5391  if (PyTuple_GET_SIZE(obj) == 2) {
5392  res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
5393  }
5394  } else if (PySequence_Check(obj)) {
5395  if (PySequence_Size(obj) == 2) {
5396  swig::SwigVar_PyObject first = PySequence_GetItem(obj,0);
5397  swig::SwigVar_PyObject second = PySequence_GetItem(obj,1);
5398  res = get_pair(first, second, val);
5399  }
5400  } else {
5401  value_type *p;
5402  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
5403  if (SWIG_IsOK(res) && val) *val = p;
5404  }
5405  return res;
5406  }
5407  };
5408 
5409 
5410  template <class T, class U >
5411  struct traits_from<std::pair<T,U> > {
5412  static PyObject *from(const std::pair<T,U>& val) {
5413  PyObject* obj = PyTuple_New(2);
5414  PyTuple_SetItem(obj,0,swig::from(val.first));
5415  PyTuple_SetItem(obj,1,swig::from(val.second));
5416  return obj;
5417  }
5418  };
5419  }
5420 
5421 
5422 
5423 
5424 
5425 
5426 
5427 
5428 
5429 
5430 
5431 
5432 
5433 
5434 
5435 
5436 
5437 
5438 
5439 
5440 
5441 
5442 
5443 
5444 
5445 
5446 
5447 
5448 
5449 
5450 
5451 
5452 
5453 
5454 
5455 
5456 
5457  namespace swig {
5458  template <> struct traits<std::pair< int, int > > {
5459  typedef pointer_category category;
5460  static const char* type_name() {
5461  return "std::pair<" "int" "," "int" " >";
5462  }
5463  };
5464  }
5465 
5466 
5467 #include <functional>
5468 
5469 namespace std {
5470  template <>
5471  struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
5472  {
5473  bool
5474  operator()(PyObject * v, PyObject *w) const
5475  {
5476  bool res;
5477  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
5478  res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
5479  /* This may fall into a case of inconsistent
5480  eg. ObjA > ObjX > ObjB
5481  but ObjA < ObjB
5482  */
5483  if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
5484  {
5485  /* Objects can't be compared, this mostly occurred in Python 3.0 */
5486  /* Compare their ptr directly for a workaround */
5487  res = (v < w);
5488  PyErr_Clear();
5489  }
5490  SWIG_PYTHON_THREAD_END_BLOCK;
5491  return res;
5492  }
5493  };
5494 
5495  template <>
5496  struct less <swig::SwigPtr_PyObject>: public binary_function<swig::SwigPtr_PyObject, swig::SwigPtr_PyObject, bool>
5497  {
5498  bool
5499  operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
5500  {
5501  return std::less<PyObject *>()(v, w);
5502  }
5503  };
5504 
5505  template <>
5506  struct less <swig::SwigVar_PyObject>: public binary_function<swig::SwigVar_PyObject, swig::SwigVar_PyObject, bool>
5507  {
5508  bool
5509  operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
5510  {
5511  return std::less<PyObject *>()(v, w);
5512  }
5513  };
5514 
5515 }
5516 
5517 namespace swig {
5518  template <> struct traits<PyObject *> {
5519  typedef value_category category;
5520  static const char* type_name() { return "PyObject *"; }
5521  };
5522 
5523  template <> struct traits_asval<PyObject * > {
5524  typedef PyObject * value_type;
5525  static int asval(PyObject *obj, value_type *val) {
5526  if (val) *val = obj;
5527  return SWIG_OK;
5528  }
5529  };
5530 
5531  template <>
5532  struct traits_check<PyObject *, value_category> {
5533  static bool check(PyObject *) {
5534  return true;
5535  }
5536  };
5537 
5538  template <> struct traits_from<PyObject *> {
5539  typedef PyObject * value_type;
5540  static PyObject *from(const value_type& val) {
5541  Py_XINCREF(val);
5542  return val;
5543  }
5544  };
5545 
5546 }
5547 
5548 namespace swig {
5549  template <class Difference>
5550  inline size_t
5551  check_index(Difference i, size_t size, bool insert = false) {
5552  if ( i < 0 ) {
5553  if ((size_t) (-i) <= size)
5554  return (size_t) (i + size);
5555  } else if ( (size_t) i < size ) {
5556  return (size_t) i;
5557  } else if (insert && ((size_t) i == size)) {
5558  return size;
5559  }
5560  throw std::out_of_range("index out of range");
5561  }
5562 
5563  template <class Difference>
5564  void
5565  slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
5566  if (step == 0) {
5567  throw std::invalid_argument("slice step cannot be zero");
5568  } else if (step > 0) {
5569  // Required range: 0 <= i < size, 0 <= j < size
5570  if (i < 0) {
5571  ii = 0;
5572  } else if (i < (Difference)size) {
5573  ii = i;
5574  } else if (insert && (i >= (Difference)size)) {
5575  ii = (Difference)size;
5576  }
5577  if ( j < 0 ) {
5578  jj = 0;
5579  } else {
5580  jj = (j < (Difference)size) ? j : (Difference)size;
5581  }
5582  } else {
5583  // Required range: -1 <= i < size-1, -1 <= j < size-1
5584  if (i < -1) {
5585  ii = -1;
5586  } else if (i < (Difference) size) {
5587  ii = i;
5588  } else if (i >= (Difference)(size-1)) {
5589  ii = (Difference)(size-1);
5590  }
5591  if (j < -1) {
5592  jj = -1;
5593  } else {
5594  jj = (j < (Difference)size ) ? j : (Difference)(size-1);
5595  }
5596  }
5597  }
5598 
5599  template <class Sequence, class Difference>
5600  inline typename Sequence::iterator
5601  getpos(Sequence* self, Difference i) {
5602  typename Sequence::iterator pos = self->begin();
5603  std::advance(pos, check_index(i,self->size()));
5604  return pos;
5605  }
5606 
5607  template <class Sequence, class Difference>
5608  inline typename Sequence::const_iterator
5609  cgetpos(const Sequence* self, Difference i) {
5610  typename Sequence::const_iterator pos = self->begin();
5611  std::advance(pos, check_index(i,self->size()));
5612  return pos;
5613  }
5614 
5615  template <class Sequence>
5616  inline void
5617  erase(Sequence* seq, const typename Sequence::iterator& position) {
5618  seq->erase(position);
5619  }
5620 
5621  template <class Sequence, class Difference>
5622  inline Sequence*
5623  getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
5624  typename Sequence::size_type size = self->size();
5625  Difference ii = 0;
5626  Difference jj = 0;
5627  swig::slice_adjust(i, j, step, size, ii, jj);
5628 
5629  if (step > 0) {
5630  typename Sequence::const_iterator sb = self->begin();
5631  typename Sequence::const_iterator se = self->begin();
5632  std::advance(sb,ii);
5633  std::advance(se,jj);
5634  if (step == 1) {
5635  return new Sequence(sb, se);
5636  } else {
5637  Sequence *sequence = new Sequence();
5638  typename Sequence::const_iterator it = sb;
5639  while (it!=se) {
5640  sequence->push_back(*it);
5641  for (Py_ssize_t c=0; c<step && it!=se; ++c)
5642  it++;
5643  }
5644  return sequence;
5645  }
5646  } else {
5647  Sequence *sequence = new Sequence();
5648  if (ii > jj) {
5649  typename Sequence::const_reverse_iterator sb = self->rbegin();
5650  typename Sequence::const_reverse_iterator se = self->rbegin();
5651  std::advance(sb,size-ii-1);
5652  std::advance(se,size-jj-1);
5653  typename Sequence::const_reverse_iterator it = sb;
5654  while (it!=se) {
5655  sequence->push_back(*it);
5656  for (Py_ssize_t c=0; c<-step && it!=se; ++c)
5657  it++;
5658  }
5659  }
5660  return sequence;
5661  }
5662  }
5663 
5664  template <class Sequence, class Difference, class InputSeq>
5665  inline void
5666  setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
5667  typename Sequence::size_type size = self->size();
5668  Difference ii = 0;
5669  Difference jj = 0;
5670  swig::slice_adjust(i, j, step, size, ii, jj, true);
5671  if (step > 0) {
5672  if (jj < ii)
5673  jj = ii;
5674  if (step == 1) {
5675  size_t ssize = jj - ii;
5676  if (ssize <= is.size()) {
5677  // expanding/staying the same size
5678  typename Sequence::iterator sb = self->begin();
5679  typename InputSeq::const_iterator isit = is.begin();
5680  std::advance(sb,ii);
5681  std::advance(isit, jj - ii);
5682  self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
5683  } else {
5684  // shrinking
5685  typename Sequence::iterator sb = self->begin();
5686  typename Sequence::iterator se = self->begin();
5687  std::advance(sb,ii);
5688  std::advance(se,jj);
5689  self->erase(sb,se);
5690  sb = self->begin();
5691  std::advance(sb,ii);
5692  self->insert(sb, is.begin(), is.end());
5693  }
5694  } else {
5695  size_t replacecount = (jj - ii + step - 1) / step;
5696  if (is.size() != replacecount) {
5697  char msg[1024];
5698  sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
5699  throw std::invalid_argument(msg);
5700  }
5701  typename Sequence::const_iterator isit = is.begin();
5702  typename Sequence::iterator it = self->begin();
5703  std::advance(it,ii);
5704  for (size_t rc=0; rc<replacecount; ++rc) {
5705  *it++ = *isit++;
5706  for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
5707  it++;
5708  }
5709  }
5710  } else {
5711  if (jj > ii)
5712  jj = ii;
5713  size_t replacecount = (ii - jj - step - 1) / -step;
5714  if (is.size() != replacecount) {
5715  char msg[1024];
5716  sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
5717  throw std::invalid_argument(msg);
5718  }
5719  typename Sequence::const_iterator isit = is.begin();
5720  typename Sequence::reverse_iterator it = self->rbegin();
5721  std::advance(it,size-ii-1);
5722  for (size_t rc=0; rc<replacecount; ++rc) {
5723  *it++ = *isit++;
5724  for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
5725  it++;
5726  }
5727  }
5728  }
5729 
5730  template <class Sequence, class Difference>
5731  inline void
5732  delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
5733  typename Sequence::size_type size = self->size();
5734  Difference ii = 0;
5735  Difference jj = 0;
5736  swig::slice_adjust(i, j, step, size, ii, jj, true);
5737  if (step > 0) {
5738  if (jj > ii) {
5739  typename Sequence::iterator sb = self->begin();
5740  std::advance(sb,ii);
5741  if (step == 1) {
5742  typename Sequence::iterator se = self->begin();
5743  std::advance(se,jj);
5744  self->erase(sb,se);
5745  } else {
5746  typename Sequence::iterator it = sb;
5747  size_t delcount = (jj - ii + step - 1) / step;
5748  while (delcount) {
5749  it = self->erase(it);
5750  for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
5751  it++;
5752  delcount--;
5753  }
5754  }
5755  }
5756  } else {
5757  if (ii > jj) {
5758  typename Sequence::reverse_iterator sb = self->rbegin();
5759  std::advance(sb,size-ii-1);
5760  typename Sequence::reverse_iterator it = sb;
5761  size_t delcount = (ii - jj - step - 1) / -step;
5762  while (delcount) {
5763  it = typename Sequence::reverse_iterator(self->erase((++it).base()));
5764  for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
5765  it++;
5766  delcount--;
5767  }
5768  }
5769  }
5770  }
5771 }
5772 
5773 
5774 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
5775 # if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
5776 # define SWIG_STD_NOITERATOR_TRAITS_STL
5777 # endif
5778 #endif
5779 
5780 #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
5781 #include <iterator>
5782 #else
5783 namespace std {
5784  template <class Iterator>
5785  struct iterator_traits {
5786  typedef ptrdiff_t difference_type;
5787  typedef typename Iterator::value_type value_type;
5788  };
5789 
5790  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
5791  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
5792  typedef Distance difference_type;
5793  typedef T value_type;
5794  };
5795 
5796  template <class T>
5797  struct iterator_traits<T*> {
5798  typedef T value_type;
5799  typedef ptrdiff_t difference_type;
5800  };
5801 
5802  template<typename _InputIterator>
5803  inline typename iterator_traits<_InputIterator>::difference_type
5804  distance(_InputIterator __first, _InputIterator __last)
5805  {
5806  typename iterator_traits<_InputIterator>::difference_type __n = 0;
5807  while (__first != __last) {
5808  ++__first; ++__n;
5809  }
5810  return __n;
5811  }
5812 }
5813 #endif
5814 
5815 
5816 namespace swig {
5817  template<typename OutIterator>
5819  {
5820  public:
5821  typedef OutIterator out_iterator;
5822  typedef typename std::iterator_traits<out_iterator>::value_type value_type;
5824 
5825  SwigPyIterator_T(out_iterator curr, PyObject *seq)
5826  : SwigPyIterator(seq), current(curr)
5827  {
5828  }
5829 
5830  const out_iterator& get_current() const
5831  {
5832  return current;
5833  }
5834 
5835 
5836  bool equal (const SwigPyIterator &iter) const
5837  {
5838  const self_type *iters = dynamic_cast<const self_type *>(&iter);
5839  if (iters) {
5840  return (current == iters->get_current());
5841  } else {
5842  throw std::invalid_argument("bad iterator type");
5843  }
5844  }
5845 
5846  ptrdiff_t distance(const SwigPyIterator &iter) const
5847  {
5848  const self_type *iters = dynamic_cast<const self_type *>(&iter);
5849  if (iters) {
5850  return std::distance(current, iters->get_current());
5851  } else {
5852  throw std::invalid_argument("bad iterator type");
5853  }
5854  }
5855 
5856  protected:
5857  out_iterator current;
5858  };
5859 
5860  template <class ValueType>
5861  struct from_oper
5862  {
5863  typedef const ValueType& argument_type;
5864  typedef PyObject *result_type;
5865  result_type operator()(argument_type v) const
5866  {
5867  return swig::from(v);
5868  }
5869  };
5870 
5871  template<typename OutIterator,
5872  typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
5873  typename FromOper = from_oper<ValueType> >
5874  class SwigPyIteratorOpen_T : public SwigPyIterator_T<OutIterator>
5875  {
5876  public:
5877  FromOper from;
5878  typedef OutIterator out_iterator;
5879  typedef ValueType value_type;
5882 
5883  SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
5884  : SwigPyIterator_T<OutIterator>(curr, seq)
5885  {
5886  }
5887 
5888  PyObject *value() const {
5889  return from(static_cast<const value_type&>(*(base::current)));
5890  }
5891 
5892  SwigPyIterator *copy() const
5893  {
5894  return new self_type(*this);
5895  }
5896 
5897  SwigPyIterator *incr(size_t n = 1)
5898  {
5899  while (n--) {
5900  ++base::current;
5901  }
5902  return this;
5903  }
5904 
5905  SwigPyIterator *decr(size_t n = 1)
5906  {
5907  while (n--) {
5908  --base::current;
5909  }
5910  return this;
5911  }
5912  };
5913 
5914  template<typename OutIterator,
5915  typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
5916  typename FromOper = from_oper<ValueType> >
5917  class SwigPyIteratorClosed_T : public SwigPyIterator_T<OutIterator>
5918  {
5919  public:
5920  FromOper from;
5921  typedef OutIterator out_iterator;
5922  typedef ValueType value_type;
5925 
5926  SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
5927  : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
5928  {
5929  }
5930 
5931  PyObject *value() const {
5932  if (base::current == end) {
5933  throw stop_iteration();
5934  } else {
5935  return from(static_cast<const value_type&>(*(base::current)));
5936  }
5937  }
5938 
5939  SwigPyIterator *copy() const
5940  {
5941  return new self_type(*this);
5942  }
5943 
5944  SwigPyIterator *incr(size_t n = 1)
5945  {
5946  while (n--) {
5947  if (base::current == end) {
5948  throw stop_iteration();
5949  } else {
5950  ++base::current;
5951  }
5952  }
5953  return this;
5954  }
5955 
5956  SwigPyIterator *decr(size_t n = 1)
5957  {
5958  while (n--) {
5959  if (base::current == begin) {
5960  throw stop_iteration();
5961  } else {
5962  --base::current;
5963  }
5964  }
5965  return this;
5966  }
5967 
5968  private:
5969  out_iterator begin;
5970  out_iterator end;
5971  };
5972 
5973  template<typename OutIter>
5974  inline SwigPyIterator*
5975  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
5976  {
5977  return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
5978  }
5979 
5980  template<typename OutIter>
5981  inline SwigPyIterator*
5982  make_output_iterator(const OutIter& current, PyObject *seq = 0)
5983  {
5984  return new SwigPyIteratorOpen_T<OutIter>(current, seq);
5985  }
5986 
5987 }
5988 
5989 
5990 namespace swig
5991 {
5992  template <class T>
5994  {
5995  SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
5996  : _seq(seq), _index(index)
5997  {
5998  }
5999 
6000  operator T () const
6001  {
6002  swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
6003  try {
6004  return swig::as<T>(item, true);
6005  } catch (std::exception& e) {
6006  char msg[1024];
6007  sprintf(msg, "in sequence element %d ", (int)_index);
6008  if (!PyErr_Occurred()) {
6009  ::SWIG_Error(SWIG_TypeError, swig::type_name<T>());
6010  }
6011  SWIG_Python_AddErrorMsg(msg);
6012  SWIG_Python_AddErrorMsg(e.what());
6013  throw;
6014  }
6015  }
6016 
6017  SwigPySequence_Ref& operator=(const T& v)
6018  {
6019  PySequence_SetItem(_seq, _index, swig::from<T>(v));
6020  return *this;
6021  }
6022 
6023  private:
6024  PyObject* _seq;
6025  Py_ssize_t _index;
6026  };
6027 
6028  template <class T>
6030  {
6031  SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
6032  const T* operator->() const { return &m_value; }
6033  operator const T*() const { return &m_value; }
6034  T m_value;
6035  };
6036 
6037  template <class T, class Reference >
6039  {
6041 
6042  typedef std::random_access_iterator_tag iterator_category;
6043  typedef Reference reference;
6044  typedef T value_type;
6045  typedef T* pointer;
6046  typedef Py_ssize_t difference_type;
6047 
6049  {
6050  }
6051 
6052  SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
6053  : _seq(seq), _index(index)
6054  {
6055  }
6056 
6057  reference operator*() const
6058  {
6059  return reference(_seq, _index);
6060  }
6061 
6063  operator->() const {
6064  return SwigPySequence_ArrowProxy<T>(operator*());
6065  }
6066 
6067  bool operator==(const self& ri) const
6068  {
6069  return (_index == ri._index) && (_seq == ri._seq);
6070  }
6071 
6072  bool operator!=(const self& ri) const
6073  {
6074  return !(operator==(ri));
6075  }
6076 
6077  self& operator ++ ()
6078  {
6079  ++_index;
6080  return *this;
6081  }
6082 
6083  self& operator -- ()
6084  {
6085  --_index;
6086  return *this;
6087  }
6088 
6089  self& operator += (difference_type n)
6090  {
6091  _index += n;
6092  return *this;
6093  }
6094 
6095  self operator +(difference_type n) const
6096  {
6097  return self(_seq, _index + n);
6098  }
6099 
6100  self& operator -= (difference_type n)
6101  {
6102  _index -= n;
6103  return *this;
6104  }
6105 
6106  self operator -(difference_type n) const
6107  {
6108  return self(_seq, _index - n);
6109  }
6110 
6111  difference_type operator - (const self& ri) const
6112  {
6113  return _index - ri._index;
6114  }
6115 
6116  bool operator < (const self& ri) const
6117  {
6118  return _index < ri._index;
6119  }
6120 
6121  reference
6122  operator[](difference_type n) const
6123  {
6124  return reference(_seq, _index + n);
6125  }
6126 
6127  private:
6128  PyObject* _seq;
6129  difference_type _index;
6130  };
6131 
6132  // STL container wrapper around a Python sequence
6133  template <class T>
6135  {
6137  typedef const SwigPySequence_Ref<T> const_reference;
6138  typedef T value_type;
6139  typedef T* pointer;
6140  typedef Py_ssize_t difference_type;
6141  typedef size_t size_type;
6142  typedef const pointer const_pointer;
6145 
6146  SwigPySequence_Cont(PyObject* seq) : _seq(0)
6147  {
6148  if (!PySequence_Check(seq)) {
6149  throw std::invalid_argument("a sequence is expected");
6150  }
6151  _seq = seq;
6152  Py_INCREF(_seq);
6153  }
6154 
6156  {
6157  Py_XDECREF(_seq);
6158  }
6159 
6160  size_type size() const
6161  {
6162  return static_cast<size_type>(PySequence_Size(_seq));
6163  }
6164 
6165  bool empty() const
6166  {
6167  return size() == 0;
6168  }
6169 
6170  iterator begin()
6171  {
6172  return iterator(_seq, 0);
6173  }
6174 
6175  const_iterator begin() const
6176  {
6177  return const_iterator(_seq, 0);
6178  }
6179 
6180  iterator end()
6181  {
6182  return iterator(_seq, size());
6183  }
6184 
6185  const_iterator end() const
6186  {
6187  return const_iterator(_seq, size());
6188  }
6189 
6190  reference operator[](difference_type n)
6191  {
6192  return reference(_seq, n);
6193  }
6194 
6195  const_reference operator[](difference_type n) const
6196  {
6197  return const_reference(_seq, n);
6198  }
6199 
6200  bool check(bool set_err = true) const
6201  {
6202  Py_ssize_t s = size();
6203  for (Py_ssize_t i = 0; i < s; ++i) {
6204  swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
6205  if (!swig::check<value_type>(item)) {
6206  if (set_err) {
6207  char msg[1024];
6208  sprintf(msg, "in sequence element %d", (int)i);
6209  SWIG_Error(SWIG_RuntimeError, msg);
6210  }
6211  return false;
6212  }
6213  }
6214  return true;
6215  }
6216 
6217  private:
6218  PyObject* _seq;
6219  };
6220 
6221 }
6222 
6223 
6224 namespace swig {
6225  template <class SwigPySeq, class Seq>
6226  inline void
6227  assign(const SwigPySeq& swigpyseq, Seq* seq) {
6228  // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
6229  typedef typename SwigPySeq::value_type value_type;
6230  typename SwigPySeq::const_iterator it = swigpyseq.begin();
6231  for (;it != swigpyseq.end(); ++it) {
6232  seq->insert(seq->end(),(value_type)(*it));
6233  }
6234  }
6235 
6236  template <class Seq, class T = typename Seq::value_type >
6238  typedef Seq sequence;
6239  typedef T value_type;
6240 
6241  static int asptr(PyObject *obj, sequence **seq) {
6242  if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
6243  sequence *p;
6244  if (::SWIG_ConvertPtr(obj,(void**)&p,
6245  swig::type_info<sequence>(),0) == SWIG_OK) {
6246  if (seq) *seq = p;
6247  return SWIG_OLDOBJ;
6248  }
6249  } else if (PySequence_Check(obj)) {
6250  try {
6251  SwigPySequence_Cont<value_type> swigpyseq(obj);
6252  if (seq) {
6253  sequence *pseq = new sequence();
6254  assign(swigpyseq, pseq);
6255  *seq = pseq;
6256  return SWIG_NEWOBJ;
6257  } else {
6258  return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
6259  }
6260  } catch (std::exception& e) {
6261  if (seq) {
6262  if (!PyErr_Occurred()) {
6263  PyErr_SetString(PyExc_TypeError, e.what());
6264  }
6265  }
6266  return SWIG_ERROR;
6267  }
6268  }
6269  return SWIG_ERROR;
6270  }
6271  };
6272 
6273  template <class Seq, class T = typename Seq::value_type >
6275  typedef Seq sequence;
6276  typedef T value_type;
6277  typedef typename Seq::size_type size_type;
6278  typedef typename sequence::const_iterator const_iterator;
6279 
6280  static PyObject *from(const sequence& seq) {
6281 #ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
6282  swig_type_info *desc = swig::type_info<sequence>();
6283  if (desc && desc->clientdata) {
6284  return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
6285  }
6286 #endif
6287  size_type size = seq.size();
6288  if (size <= (size_type)INT_MAX) {
6289  PyObject *obj = PyTuple_New((Py_ssize_t)size);
6290  Py_ssize_t i = 0;
6291  for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
6292  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
6293  }
6294  return obj;
6295  } else {
6296  PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
6297  return NULL;
6298  }
6299  }
6300  };
6301 }
6302 
6303 
6304  namespace swig {
6305  template <class ValueType>
6307  {
6308  typedef const ValueType& argument_type;
6309  typedef PyObject *result_type;
6310  result_type operator()(argument_type v) const
6311  {
6312  return swig::from(v.first);
6313  }
6314  };
6315 
6316  template <class ValueType>
6318  {
6319  typedef const ValueType& argument_type;
6320  typedef PyObject *result_type;
6321  result_type operator()(argument_type v) const
6322  {
6323  return swig::from(v.second);
6324  }
6325  };
6326 
6327  template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
6328  struct SwigPyMapIterator_T : SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper>
6329  {
6330  SwigPyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
6332  {
6333  }
6334  };
6335 
6336 
6337  template<class OutIterator,
6339  struct SwigPyMapKeyIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
6340  {
6341  SwigPyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
6342  : SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
6343  {
6344  }
6345  };
6346 
6347  template<typename OutIter>
6348  inline SwigPyIterator*
6349  make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
6350  {
6351  return new SwigPyMapKeyIterator_T<OutIter>(current, begin, end, seq);
6352  }
6353 
6354  template<class OutIterator,
6355  class FromOper = from_value_oper<typename OutIterator::value_type> >
6356  struct SwigPyMapValueITerator_T : SwigPyMapIterator_T<OutIterator, FromOper>
6357  {
6358  SwigPyMapValueITerator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
6359  : SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
6360  {
6361  }
6362  };
6363 
6364 
6365  template<typename OutIter>
6366  inline SwigPyIterator*
6367  make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
6368  {
6369  return new SwigPyMapValueITerator_T<OutIter>(current, begin, end, seq);
6370  }
6371  }
6372 
6373 
6374  namespace swig {
6375  template <class SwigPySeq, class K, class T, class Compare, class Alloc >
6376  inline void
6377  assign(const SwigPySeq& swigpyseq, std::map<K,T,Compare,Alloc > *map) {
6378  typedef typename std::map<K,T,Compare,Alloc >::value_type value_type;
6379  typename SwigPySeq::const_iterator it = swigpyseq.begin();
6380  for (;it != swigpyseq.end(); ++it) {
6381  map->insert(value_type(it->first, it->second));
6382  }
6383  }
6384 
6385  template <class K, class T, class Compare, class Alloc>
6386  struct traits_asptr<std::map<K,T,Compare,Alloc > > {
6387  typedef std::map<K,T,Compare,Alloc > map_type;
6388  static int asptr(PyObject *obj, map_type **val) {
6389  int res = SWIG_ERROR;
6390  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6391  if (PyDict_Check(obj)) {
6392  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
6393 #if PY_VERSION_HEX >= 0x03000000
6394  /* In Python 3.x the ".items()" method returns a dict_items object */
6395  items = PySequence_Fast(items, ".items() didn't return a sequence!");
6396 #endif
6397  res = traits_asptr_stdseq<map_type, std::pair<K, T> >::asptr(items, val);
6398  } else {
6399  map_type *p;
6400  res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
6401  if (SWIG_IsOK(res) && val) *val = p;
6402  }
6403  SWIG_PYTHON_THREAD_END_BLOCK;
6404  return res;
6405  }
6406  };
6407 
6408  template <class K, class T, class Compare, class Alloc >
6409  struct traits_from<std::map<K,T,Compare,Alloc > > {
6410  typedef std::map<K,T,Compare,Alloc > map_type;
6411  typedef typename map_type::const_iterator const_iterator;
6412  typedef typename map_type::size_type size_type;
6413 
6414  static PyObject *asdict(const map_type& map) {
6415  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6416  size_type size = map.size();
6417  Py_ssize_t pysize = (size <= (size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6418  if (pysize < 0) {
6419  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6420  SWIG_PYTHON_THREAD_END_BLOCK;
6421  return NULL;
6422  }
6423  PyObject *obj = PyDict_New();
6424  for (const_iterator i= map.begin(); i!= map.end(); ++i) {
6425  swig::SwigVar_PyObject key = swig::from(i->first);
6426  swig::SwigVar_PyObject val = swig::from(i->second);
6427  PyDict_SetItem(obj, key, val);
6428  }
6429  SWIG_PYTHON_THREAD_END_BLOCK;
6430  return obj;
6431  }
6432 
6433  static PyObject *from(const map_type& map) {
6434  swig_type_info *desc = swig::type_info<map_type>();
6435  if (desc && desc->clientdata) {
6436  return SWIG_InternalNewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
6437  } else {
6438  return asdict(map);
6439  }
6440  }
6441  };
6442  }
6443 
6444 
6445  namespace swig {
6446  template <> struct traits<std::map< int, int, std::less< int >, std::allocator< std::pair< int const,int > > > > {
6447  typedef pointer_category category;
6448  static const char* type_name() {
6449  return "std::map<" "int" "," "int" "," "std::less< int >" "," "std::allocator< std::pair< int const,int > >" " >";
6450  }
6451  };
6452  }
6453 
6454 SWIGINTERN swig::SwigPyIterator *std_map_Sl_int_Sc_int_Sg__iterator(std::map< int,int > *self,PyObject **PYTHON_SELF){
6455  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6456  }
6457 SWIGINTERN bool std_map_Sl_int_Sc_int_Sg____nonzero__(std::map< int,int > const *self){
6458  return !(self->empty());
6459  }
6460 SWIGINTERN bool std_map_Sl_int_Sc_int_Sg____bool__(std::map< int,int > const *self){
6461  return !(self->empty());
6462  }
6463 SWIGINTERN std::map< int,int >::size_type std_map_Sl_int_Sc_int_Sg____len__(std::map< int,int > const *self){
6464  return self->size();
6465  }
6466 SWIGINTERN std::map< int,int >::mapped_type const &std_map_Sl_int_Sc_int_Sg____getitem__(std::map< int,int > *self,std::map< int,int >::key_type const &key){
6467  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->find(key);
6468  if (i != self->end())
6469  return i->second;
6470  else
6471  throw std::out_of_range("key not found");
6472  }
6473 SWIGINTERN void std_map_Sl_int_Sc_int_Sg____delitem__(std::map< int,int > *self,std::map< int,int >::key_type const &key){
6474  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::iterator i = self->find(key);
6475  if (i != self->end())
6476  self->erase(i);
6477  else
6478  throw std::out_of_range("key not found");
6479  }
6480 SWIGINTERN bool std_map_Sl_int_Sc_int_Sg__has_key(std::map< int,int > const *self,std::map< int,int >::key_type const &key){
6481  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->find(key);
6482  return i != self->end();
6483  }
6484 SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__keys(std::map< int,int > *self){
6485  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type size = self->size();
6486  Py_ssize_t pysize = (size <= (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6487  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6488  if (pysize < 0) {
6489  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6490  SWIG_PYTHON_THREAD_END_BLOCK;
6491  return NULL;
6492  }
6493  PyObject* keyList = PyList_New(pysize);
6494  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->begin();
6495  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6496  PyList_SET_ITEM(keyList, j, swig::from(i->first));
6497  }
6498  SWIG_PYTHON_THREAD_END_BLOCK;
6499  return keyList;
6500  }
6501 SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__values(std::map< int,int > *self){
6502  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type size = self->size();
6503  Py_ssize_t pysize = (size <= (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6504  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6505  if (pysize < 0) {
6506  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6507  SWIG_PYTHON_THREAD_END_BLOCK;
6508  return NULL;
6509  }
6510  PyObject* valList = PyList_New(pysize);
6511  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->begin();
6512  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6513  PyList_SET_ITEM(valList, j, swig::from(i->second));
6514  }
6515  SWIG_PYTHON_THREAD_END_BLOCK;
6516  return valList;
6517  }
6518 SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__items(std::map< int,int > *self){
6519  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type size = self->size();
6520  Py_ssize_t pysize = (size <= (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6521  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6522  if (pysize < 0) {
6523  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6524  SWIG_PYTHON_THREAD_END_BLOCK;
6525  return NULL;
6526  }
6527  PyObject* itemList = PyList_New(pysize);
6528  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->begin();
6529  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6530  PyList_SET_ITEM(itemList, j, swig::from(*i));
6531  }
6532  SWIG_PYTHON_THREAD_END_BLOCK;
6533  return itemList;
6534  }
6535 SWIGINTERN bool std_map_Sl_int_Sc_int_Sg____contains__(std::map< int,int > *self,std::map< int,int >::key_type const &key){
6536  return self->find(key) != self->end();
6537  }
6538 SWIGINTERN swig::SwigPyIterator *std_map_Sl_int_Sc_int_Sg__key_iterator(std::map< int,int > *self,PyObject **PYTHON_SELF){
6539  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6540  }
6541 SWIGINTERN swig::SwigPyIterator *std_map_Sl_int_Sc_int_Sg__value_iterator(std::map< int,int > *self,PyObject **PYTHON_SELF){
6542  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6543  }
6544 SWIGINTERN void std_map_Sl_int_Sc_int_Sg____setitem____SWIG_0(std::map< int,int > *self,std::map< int,int >::key_type const &key){
6545  self->erase(key);
6546  }
6547 SWIGINTERN void std_map_Sl_int_Sc_int_Sg____setitem____SWIG_1(std::map< int,int > *self,std::map< int,int >::key_type const &key,std::map< int,int >::mapped_type const &x){
6548  (*self)[key] = x;
6549  }
6550 SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__asdict(std::map< int,int > *self){
6551  return swig::traits_from< std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > >::asdict(*self);
6552  }
6553 SWIGINTERN void std_map_Sl_int_Sc_int_Sg__erase__SWIG_1(std::map< int,int > *self,std::map< int,int >::iterator position){ self->erase(position); }
6554 SWIGINTERN void std_map_Sl_int_Sc_int_Sg__erase__SWIG_2(std::map< int,int > *self,std::map< int,int >::iterator first,std::map< int,int >::iterator last){ self->erase(first, last); }
6555 
6556 SWIGINTERN int
6557 SWIG_AsPtr_std_string (PyObject * obj, std::string **val)
6558 {
6559  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
6560  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
6561  if (buf) {
6562  if (val) *val = new std::string(buf, size - 1);
6563  if (alloc == SWIG_NEWOBJ) delete[] buf;
6564  return SWIG_NEWOBJ;
6565  } else {
6566  if (val) *val = 0;
6567  return SWIG_OLDOBJ;
6568  }
6569  } else {
6570  static int init = 0;
6571  static swig_type_info* descriptor = 0;
6572  if (!init) {
6573  descriptor = SWIG_TypeQuery("std::string" " *");
6574  init = 1;
6575  }
6576  if (descriptor) {
6577  std::string *vptr;
6578  int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
6579  if (SWIG_IsOK(res) && val) *val = vptr;
6580  return res;
6581  }
6582  }
6583  return SWIG_ERROR;
6584 }
6585 
6586 
6587 SWIGINTERN int
6588 SWIG_AsVal_std_string (PyObject * obj, std::string *val)
6589 {
6590  std::string* v = (std::string *) 0;
6591  int res = SWIG_AsPtr_std_string (obj, &v);
6592  if (!SWIG_IsOK(res)) return res;
6593  if (v) {
6594  if (val) *val = *v;
6595  if (SWIG_IsNewObj(res)) {
6596  delete v;
6597  res = SWIG_DelNewMask(res);
6598  }
6599  return res;
6600  }
6601  return SWIG_ERROR;
6602 }
6603 
6604 
6605 SWIGINTERNINLINE PyObject *
6606 SWIG_From_std_string (const std::string& s)
6607 {
6608  return SWIG_FromCharPtrAndSize(s.data(), s.size());
6609 }
6610 
6611 
6612 namespace swig {
6613  template <> struct traits< std::string > {
6614  typedef value_category category;
6615  static const char* type_name() { return"std::string"; }
6616  };
6617  template <> struct traits_asval< std::string > {
6618  typedef std::string value_type;
6619  static int asval(PyObject *obj, value_type *val) {
6620  return SWIG_AsVal_std_string (obj, val);
6621  }
6622  };
6623  template <> struct traits_from< std::string > {
6624  typedef std::string value_type;
6625  static PyObject *from(const value_type& val) {
6626  return SWIG_From_std_string (val);
6627  }
6628  };
6629 }
6630 
6631 
6632  namespace swig {
6633  template <> struct traits<std::pair< std::string, std::string > > {
6634  typedef pointer_category category;
6635  static const char* type_name() {
6636  return "std::pair<" "std::string" "," "std::string" " >";
6637  }
6638  };
6639  }
6640 
6641 
6642  namespace swig {
6643  template <> struct traits<std::map< std::string, std::string, std::less< std::string >, std::allocator< std::pair< std::string const,std::string > > > > {
6644  typedef pointer_category category;
6645  static const char* type_name() {
6646  return "std::map<" "std::string" "," "std::string" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,std::string > >" " >";
6647  }
6648  };
6649  }
6650 
6651 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_std_string_Sg__iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
6652  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6653  }
6654 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____nonzero__(std::map< std::string,std::string > const *self){
6655  return !(self->empty());
6656  }
6657 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____bool__(std::map< std::string,std::string > const *self){
6658  return !(self->empty());
6659  }
6660 SWIGINTERN std::map< std::string,std::string >::size_type std_map_Sl_std_string_Sc_std_string_Sg____len__(std::map< std::string,std::string > const *self){
6661  return self->size();
6662  }
6663 SWIGINTERN std::map< std::string,std::string >::mapped_type const &std_map_Sl_std_string_Sc_std_string_Sg____getitem__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
6664  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->find(key);
6665  if (i != self->end())
6666  return i->second;
6667  else
6668  throw std::out_of_range("key not found");
6669  }
6670 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____delitem__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
6671  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::iterator i = self->find(key);
6672  if (i != self->end())
6673  self->erase(i);
6674  else
6675  throw std::out_of_range("key not found");
6676  }
6677 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__has_key(std::map< std::string,std::string > const *self,std::map< std::string,std::string >::key_type const &key){
6678  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->find(key);
6679  return i != self->end();
6680  }
6681 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__keys(std::map< std::string,std::string > *self){
6682  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
6683  Py_ssize_t pysize = (size <= (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6684  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6685  if (pysize < 0) {
6686  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6687  SWIG_PYTHON_THREAD_END_BLOCK;
6688  return NULL;
6689  }
6690  PyObject* keyList = PyList_New(pysize);
6691  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
6692  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6693  PyList_SET_ITEM(keyList, j, swig::from(i->first));
6694  }
6695  SWIG_PYTHON_THREAD_END_BLOCK;
6696  return keyList;
6697  }
6698 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__values(std::map< std::string,std::string > *self){
6699  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
6700  Py_ssize_t pysize = (size <= (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6701  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6702  if (pysize < 0) {
6703  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6704  SWIG_PYTHON_THREAD_END_BLOCK;
6705  return NULL;
6706  }
6707  PyObject* valList = PyList_New(pysize);
6708  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
6709  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6710  PyList_SET_ITEM(valList, j, swig::from(i->second));
6711  }
6712  SWIG_PYTHON_THREAD_END_BLOCK;
6713  return valList;
6714  }
6715 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__items(std::map< std::string,std::string > *self){
6716  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
6717  Py_ssize_t pysize = (size <= (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6718  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6719  if (pysize < 0) {
6720  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6721  SWIG_PYTHON_THREAD_END_BLOCK;
6722  return NULL;
6723  }
6724  PyObject* itemList = PyList_New(pysize);
6725  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
6726  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6727  PyList_SET_ITEM(itemList, j, swig::from(*i));
6728  }
6729  SWIG_PYTHON_THREAD_END_BLOCK;
6730  return itemList;
6731  }
6732 SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____contains__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
6733  return self->find(key) != self->end();
6734  }
6735 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_std_string_Sg__key_iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
6736  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6737  }
6738 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_std_string_Sg__value_iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
6739  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6740  }
6741 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____setitem____SWIG_0(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
6742  self->erase(key);
6743  }
6744 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____setitem____SWIG_1(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key,std::map< std::string,std::string >::mapped_type const &x){
6745  (*self)[key] = x;
6746  }
6747 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__asdict(std::map< std::string,std::string > *self){
6748  return swig::traits_from< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > >::asdict(*self);
6749  }
6750 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__erase__SWIG_1(std::map< std::string,std::string > *self,std::map< std::string,std::string >::iterator position){ self->erase(position); }
6751 SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__erase__SWIG_2(std::map< std::string,std::string > *self,std::map< std::string,std::string >::iterator first,std::map< std::string,std::string >::iterator last){ self->erase(first, last); }
6752 
6753  #define SWIG_From_double PyFloat_FromDouble
6754 
6755 
6756 namespace swig {
6757  template <> struct traits< double > {
6758  typedef value_category category;
6759  static const char* type_name() { return"double"; }
6760  };
6761  template <> struct traits_asval< double > {
6762  typedef double value_type;
6763  static int asval(PyObject *obj, value_type *val) {
6764  return SWIG_AsVal_double (obj, val);
6765  }
6766  };
6767  template <> struct traits_from< double > {
6768  typedef double value_type;
6769  static PyObject *from(const value_type& val) {
6770  return SWIG_From_double (val);
6771  }
6772  };
6773 }
6774 
6775 
6776  namespace swig {
6777  template <> struct traits<std::pair< double, std::pair< int,int > > > {
6778  typedef pointer_category category;
6779  static const char* type_name() {
6780  return "std::pair<" "double" "," "std::pair< int,int >" " >";
6781  }
6782  };
6783  }
6784 
6785 
6786  namespace swig {
6787  template <> struct traits<std::map< double, std::pair< int,int >, std::less< double >, std::allocator< std::pair< double const,std::pair< int,int > > > > > {
6788  typedef pointer_category category;
6789  static const char* type_name() {
6790  return "std::map<" "double" "," "std::pair< int,int >" "," "std::less< double >" "," "std::allocator< std::pair< double const,std::pair< int,int > > >" " >";
6791  }
6792  };
6793  }
6794 
6795 SWIGINTERN swig::SwigPyIterator *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__iterator(std::map< double,std::pair< int,int > > *self,PyObject **PYTHON_SELF){
6796  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6797  }
6798 SWIGINTERN bool std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____nonzero__(std::map< double,std::pair< int,int > > const *self){
6799  return !(self->empty());
6800  }
6801 SWIGINTERN bool std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____bool__(std::map< double,std::pair< int,int > > const *self){
6802  return !(self->empty());
6803  }
6804 SWIGINTERN std::map< double,std::pair< int,int > >::size_type std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____len__(std::map< double,std::pair< int,int > > const *self){
6805  return self->size();
6806  }
6807 SWIGINTERN std::map< double,std::pair< int,int > >::mapped_type const &std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____getitem__(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::key_type const &key){
6808  std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::const_iterator i = self->find(key);
6809  if (i != self->end())
6810  return i->second;
6811  else
6812  throw std::out_of_range("key not found");
6813  }
6814 SWIGINTERN void std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____delitem__(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::key_type const &key){
6815  std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::iterator i = self->find(key);
6816  if (i != self->end())
6817  self->erase(i);
6818  else
6819  throw std::out_of_range("key not found");
6820  }
6821 SWIGINTERN bool std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__has_key(std::map< double,std::pair< int,int > > const *self,std::map< double,std::pair< int,int > >::key_type const &key){
6822  std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::const_iterator i = self->find(key);
6823  return i != self->end();
6824  }
6825 SWIGINTERN PyObject *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__keys(std::map< double,std::pair< int,int > > *self){
6826  std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type size = self->size();
6827  Py_ssize_t pysize = (size <= (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6828  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6829  if (pysize < 0) {
6830  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6831  SWIG_PYTHON_THREAD_END_BLOCK;
6832  return NULL;
6833  }
6834  PyObject* keyList = PyList_New(pysize);
6835  std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::const_iterator i = self->begin();
6836  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6837  PyList_SET_ITEM(keyList, j, swig::from(i->first));
6838  }
6839  SWIG_PYTHON_THREAD_END_BLOCK;
6840  return keyList;
6841  }
6842 SWIGINTERN PyObject *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__values(std::map< double,std::pair< int,int > > *self){
6843  std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type size = self->size();
6844  Py_ssize_t pysize = (size <= (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6845  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6846  if (pysize < 0) {
6847  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6848  SWIG_PYTHON_THREAD_END_BLOCK;
6849  return NULL;
6850  }
6851  PyObject* valList = PyList_New(pysize);
6852  std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::const_iterator i = self->begin();
6853  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6854  PyList_SET_ITEM(valList, j, swig::from(i->second));
6855  }
6856  SWIG_PYTHON_THREAD_END_BLOCK;
6857  return valList;
6858  }
6859 SWIGINTERN PyObject *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__items(std::map< double,std::pair< int,int > > *self){
6860  std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type size = self->size();
6861  Py_ssize_t pysize = (size <= (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
6862  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
6863  if (pysize < 0) {
6864  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
6865  SWIG_PYTHON_THREAD_END_BLOCK;
6866  return NULL;
6867  }
6868  PyObject* itemList = PyList_New(pysize);
6869  std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::const_iterator i = self->begin();
6870  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
6871  PyList_SET_ITEM(itemList, j, swig::from(*i));
6872  }
6873  SWIG_PYTHON_THREAD_END_BLOCK;
6874  return itemList;
6875  }
6876 SWIGINTERN bool std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____contains__(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::key_type const &key){
6877  return self->find(key) != self->end();
6878  }
6879 SWIGINTERN swig::SwigPyIterator *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__key_iterator(std::map< double,std::pair< int,int > > *self,PyObject **PYTHON_SELF){
6880  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6881  }
6882 SWIGINTERN swig::SwigPyIterator *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__value_iterator(std::map< double,std::pair< int,int > > *self,PyObject **PYTHON_SELF){
6883  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6884  }
6885 SWIGINTERN void std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_0(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::key_type const &key){
6886  self->erase(key);
6887  }
6888 SWIGINTERN void std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_1(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::key_type const &key,std::map< double,std::pair< int,int > >::mapped_type const &x){
6889  (*self)[key] = x;
6890  }
6891 SWIGINTERN PyObject *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__asdict(std::map< double,std::pair< int,int > > *self){
6892  return swig::traits_from< std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > > >::asdict(*self);
6893  }
6894 SWIGINTERN void std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_1(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::iterator position){ self->erase(position); }
6895 SWIGINTERN void std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_2(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::iterator first,std::map< double,std::pair< int,int > >::iterator last){ self->erase(first, last); }
6896 
6897 namespace swig {
6898  template <> struct traits< bool > {
6899  typedef value_category category;
6900  static const char* type_name() { return"bool"; }
6901  };
6902  template <> struct traits_asval< bool > {
6903  typedef bool value_type;
6904  static int asval(PyObject *obj, value_type *val) {
6905  return SWIG_AsVal_bool (obj, val);
6906  }
6907  };
6908  template <> struct traits_from< bool > {
6909  typedef bool value_type;
6910  static PyObject *from(const value_type& val) {
6911  return SWIG_From_bool (val);
6912  }
6913  };
6914 }
6915 
6916 
6917  namespace swig {
6918  template <class T>
6919  struct traits_asptr<std::vector<T> > {
6920  static int asptr(PyObject *obj, std::vector<T> **vec) {
6921  return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
6922  }
6923  };
6924 
6925  template <class T>
6926  struct traits_from<std::vector<T> > {
6927  static PyObject *from(const std::vector<T>& vec) {
6928  return traits_from_stdseq<std::vector<T> >::from(vec);
6929  }
6930  };
6931  }
6932 
6933 
6934  namespace swig {
6935  template <> struct traits<std::vector<bool, std::allocator< bool > > > {
6936  typedef value_category category;
6937  static const char* type_name() {
6938  return "std::vector<bool, std::allocator< bool > >";
6939  }
6940  };
6941  }
6942 
6943 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_bool_Sg__iterator(std::vector< bool > *self,PyObject **PYTHON_SELF){
6944  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
6945  }
6946 SWIGINTERN bool std_vector_Sl_bool_Sg____nonzero__(std::vector< bool > const *self){
6947  return !(self->empty());
6948  }
6949 SWIGINTERN bool std_vector_Sl_bool_Sg____bool__(std::vector< bool > const *self){
6950  return !(self->empty());
6951  }
6952 SWIGINTERN std::vector< bool >::size_type std_vector_Sl_bool_Sg____len__(std::vector< bool > const *self){
6953  return self->size();
6954  }
6955 SWIGINTERN std::vector< bool,std::allocator< bool > > *std_vector_Sl_bool_Sg____getslice__(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
6956  return swig::getslice(self, i, j, 1);
6957  }
6958 SWIGINTERN void std_vector_Sl_bool_Sg____setslice____SWIG_0(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
6959  swig::setslice(self, i, j, 1, std::vector<bool,std::allocator< bool > >());
6960  }
6961 SWIGINTERN void std_vector_Sl_bool_Sg____setslice____SWIG_1(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j,std::vector< bool,std::allocator< bool > > const &v){
6962  swig::setslice(self, i, j, 1, v);
6963  }
6964 SWIGINTERN void std_vector_Sl_bool_Sg____delslice__(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
6965  swig::delslice(self, i, j, 1);
6966  }
6967 SWIGINTERN void std_vector_Sl_bool_Sg____delitem____SWIG_0(std::vector< bool > *self,std::vector< bool >::difference_type i){
6968  swig::erase(self, swig::getpos(self, i));
6969  }
6970 SWIGINTERN std::vector< bool,std::allocator< bool > > *std_vector_Sl_bool_Sg____getitem____SWIG_0(std::vector< bool > *self,PySliceObject *slice){
6971  Py_ssize_t i, j, step;
6972  if( !PySlice_Check(slice) ) {
6973  SWIG_Error(SWIG_TypeError, "Slice object expected.");
6974  return NULL;
6975  }
6976  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
6977  std::vector<bool,std::allocator< bool > >::difference_type id = i;
6978  std::vector<bool,std::allocator< bool > >::difference_type jd = j;
6979  return swig::getslice(self, id, jd, step);
6980  }
6981 SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_0(std::vector< bool > *self,PySliceObject *slice,std::vector< bool,std::allocator< bool > > const &v){
6982  Py_ssize_t i, j, step;
6983  if( !PySlice_Check(slice) ) {
6984  SWIG_Error(SWIG_TypeError, "Slice object expected.");
6985  return;
6986  }
6987  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
6988  std::vector<bool,std::allocator< bool > >::difference_type id = i;
6989  std::vector<bool,std::allocator< bool > >::difference_type jd = j;
6990  swig::setslice(self, id, jd, step, v);
6991  }
6992 SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_1(std::vector< bool > *self,PySliceObject *slice){
6993  Py_ssize_t i, j, step;
6994  if( !PySlice_Check(slice) ) {
6995  SWIG_Error(SWIG_TypeError, "Slice object expected.");
6996  return;
6997  }
6998  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
6999  std::vector<bool,std::allocator< bool > >::difference_type id = i;
7000  std::vector<bool,std::allocator< bool > >::difference_type jd = j;
7001  swig::delslice(self, id, jd, step);
7002  }
7003 SWIGINTERN void std_vector_Sl_bool_Sg____delitem____SWIG_1(std::vector< bool > *self,PySliceObject *slice){
7004  Py_ssize_t i, j, step;
7005  if( !PySlice_Check(slice) ) {
7006  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7007  return;
7008  }
7009  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7010  std::vector<bool,std::allocator< bool > >::difference_type id = i;
7011  std::vector<bool,std::allocator< bool > >::difference_type jd = j;
7012  swig::delslice(self, id, jd, step);
7013  }
7014 SWIGINTERN std::vector< bool >::value_type std_vector_Sl_bool_Sg____getitem____SWIG_1(std::vector< bool > *self,std::vector< bool >::difference_type i){
7015  return *(swig::cgetpos(self, i));
7016  }
7017 SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_2(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::value_type x){
7018  *(swig::getpos(self,i)) = x;
7019  }
7020 SWIGINTERN std::vector< bool >::value_type std_vector_Sl_bool_Sg__pop(std::vector< bool > *self){
7021  if (self->size() == 0)
7022  throw std::out_of_range("pop from empty container");
7023  std::vector<bool,std::allocator< bool > >::value_type x = self->back();
7024  self->pop_back();
7025  return x;
7026  }
7027 SWIGINTERN void std_vector_Sl_bool_Sg__append(std::vector< bool > *self,std::vector< bool >::value_type x){
7028  self->push_back(x);
7029  }
7030 SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__erase__SWIG_0(std::vector< bool > *self,std::vector< bool >::iterator pos){ return self->erase(pos); }
7031 SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__erase__SWIG_1(std::vector< bool > *self,std::vector< bool >::iterator first,std::vector< bool >::iterator last){ return self->erase(first, last); }
7032 SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__insert__SWIG_0(std::vector< bool > *self,std::vector< bool >::iterator pos,std::vector< bool >::value_type x){ return self->insert(pos, x); }
7033 SWIGINTERN void std_vector_Sl_bool_Sg__insert__SWIG_1(std::vector< bool > *self,std::vector< bool >::iterator pos,std::vector< bool >::size_type n,std::vector< bool >::value_type x){ self->insert(pos, n, x); }
7034 
7035 SWIGINTERN int
7036 SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
7037 {
7038  if (PyComplex_Check(o)) {
7039  if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
7040  return SWIG_OK;
7041  } else {
7042  double d;
7043  int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
7044  if (SWIG_IsOK(res)) {
7045  if (val) *val = std::complex<double>(d, 0.0);
7046  return res;
7047  }
7048  }
7049  return SWIG_TypeError;
7050 }
7051 
7052 
7053 SWIGINTERNINLINE PyObject*
7054 SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig3.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
7055 
7056 const std::complex<double>&
7057 
7058 
7059 
7060 /*@SWIG@*/ c)
7061 {
7062  return PyComplex_FromDoubles(std::real(c), std::imag(c));
7063 }
7064 
7065 
7066 namespace swig {
7067  template <> struct traits< std::complex<double> > {
7068  typedef value_category category;
7069  static const char* type_name() { return"std::complex<double>"; }
7070  };
7071  template <> struct traits_asval< std::complex<double> > {
7072  typedef std::complex<double> value_type;
7073  static int asval(PyObject *obj, value_type *val) {
7074  return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
7075  }
7076  };
7077  template <> struct traits_from< std::complex<double> > {
7078  typedef std::complex<double> value_type;
7079  static PyObject *from(const value_type& val) {
7080  return SWIG_From_std_complex_Sl_double_Sg_ (val);
7081  }
7082  };
7083 }
7084 
7085 
7086  namespace swig {
7087  template <> struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
7088  typedef pointer_category category;
7089  static const char* type_name() {
7090  return "std::vector<" "std::complex< double >" "," "std::allocator< std::complex< double > >" " >";
7091  }
7092  };
7093  }
7094 
7095 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_complex_Sl_double_Sg__Sg__iterator(std::vector< std::complex< double > > *self,PyObject **PYTHON_SELF){
7096  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
7097  }
7098 SWIGINTERN bool std_vector_Sl_std_complex_Sl_double_Sg__Sg____nonzero__(std::vector< std::complex< double > > const *self){
7099  return !(self->empty());
7100  }
7101 SWIGINTERN bool std_vector_Sl_std_complex_Sl_double_Sg__Sg____bool__(std::vector< std::complex< double > > const *self){
7102  return !(self->empty());
7103  }
7104 SWIGINTERN std::vector< std::complex< double > >::size_type std_vector_Sl_std_complex_Sl_double_Sg__Sg____len__(std::vector< std::complex< double > > const *self){
7105  return self->size();
7106  }
7107 SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getslice__(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
7108  return swig::getslice(self, i, j, 1);
7109  }
7110 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
7111  swig::setslice(self, i, j, 1, std::vector< std::complex< double >,std::allocator< std::complex< double > > >());
7112  }
7113 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
7114  swig::setslice(self, i, j, 1, v);
7115  }
7116 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
7117  swig::delslice(self, i, j, 1);
7118  }
7119 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
7120  swig::erase(self, swig::getpos(self, i));
7121  }
7122 SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
7123  Py_ssize_t i, j, step;
7124  if( !PySlice_Check(slice) ) {
7125  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7126  return NULL;
7127  }
7128  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7129  std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
7130  std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
7131  return swig::getslice(self, id, jd, step);
7132  }
7133 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
7134  Py_ssize_t i, j, step;
7135  if( !PySlice_Check(slice) ) {
7136  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7137  return;
7138  }
7139  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7140  std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
7141  std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
7142  swig::setslice(self, id, jd, step, v);
7143  }
7144 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
7145  Py_ssize_t i, j, step;
7146  if( !PySlice_Check(slice) ) {
7147  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7148  return;
7149  }
7150  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7151  std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
7152  std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
7153  swig::delslice(self, id, jd, step);
7154  }
7155 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
7156  Py_ssize_t i, j, step;
7157  if( !PySlice_Check(slice) ) {
7158  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7159  return;
7160  }
7161  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7162  std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
7163  std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
7164  swig::delslice(self, id, jd, step);
7165  }
7166 SWIGINTERN std::vector< std::complex< double > >::value_type const &std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::complex< double > > const *self,std::vector< std::complex< double > >::difference_type i){
7167  return *(swig::cgetpos(self, i));
7168  }
7169 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::value_type const &x){
7170  *(swig::getpos(self,i)) = x;
7171  }
7172 SWIGINTERN std::vector< std::complex< double > >::value_type std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(std::vector< std::complex< double > > *self){
7173  if (self->size() == 0)
7174  throw std::out_of_range("pop from empty container");
7175  std::vector< std::complex< double >,std::allocator< std::complex< double > > >::value_type x = self->back();
7176  self->pop_back();
7177  return x;
7178  }
7179 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg__append(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::value_type const &x){
7180  self->push_back(x);
7181  }
7182 SWIGINTERN std::vector< std::complex< double > >::iterator std_vector_Sl_std_complex_Sl_double_Sg__Sg__erase__SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::iterator pos){ return self->erase(pos); }
7183 SWIGINTERN std::vector< std::complex< double > >::iterator std_vector_Sl_std_complex_Sl_double_Sg__Sg__erase__SWIG_1(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::iterator first,std::vector< std::complex< double > >::iterator last){ return self->erase(first, last); }
7184 SWIGINTERN std::vector< std::complex< double > >::iterator std_vector_Sl_std_complex_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::iterator pos,std::vector< std::complex< double > >::value_type const &x){ return self->insert(pos, x); }
7185 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::iterator pos,std::vector< std::complex< double > >::size_type n,std::vector< std::complex< double > >::value_type const &x){ self->insert(pos, n, x); }
7186 
7187  namespace swig {
7188  template <> struct traits<std::vector< double, std::allocator< double > > > {
7189  typedef pointer_category category;
7190  static const char* type_name() {
7191  return "std::vector<" "double" "," "std::allocator< double >" " >";
7192  }
7193  };
7194  }
7195 
7196 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
7197  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
7198  }
7199 SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
7200  return !(self->empty());
7201  }
7202 SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
7203  return !(self->empty());
7204  }
7205 SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
7206  return self->size();
7207  }
7208 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
7209  return swig::getslice(self, i, j, 1);
7210  }
7211 SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
7212  swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
7213  }
7214 SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
7215  swig::setslice(self, i, j, 1, v);
7216  }
7217 SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
7218  swig::delslice(self, i, j, 1);
7219  }
7220 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
7221  swig::erase(self, swig::getpos(self, i));
7222  }
7223 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
7224  Py_ssize_t i, j, step;
7225  if( !PySlice_Check(slice) ) {
7226  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7227  return NULL;
7228  }
7229  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7230  std::vector< double,std::allocator< double > >::difference_type id = i;
7231  std::vector< double,std::allocator< double > >::difference_type jd = j;
7232  return swig::getslice(self, id, jd, step);
7233  }
7234 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
7235  Py_ssize_t i, j, step;
7236  if( !PySlice_Check(slice) ) {
7237  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7238  return;
7239  }
7240  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7241  std::vector< double,std::allocator< double > >::difference_type id = i;
7242  std::vector< double,std::allocator< double > >::difference_type jd = j;
7243  swig::setslice(self, id, jd, step, v);
7244  }
7245 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
7246  Py_ssize_t i, j, step;
7247  if( !PySlice_Check(slice) ) {
7248  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7249  return;
7250  }
7251  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7252  std::vector< double,std::allocator< double > >::difference_type id = i;
7253  std::vector< double,std::allocator< double > >::difference_type jd = j;
7254  swig::delslice(self, id, jd, step);
7255  }
7256 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
7257  Py_ssize_t i, j, step;
7258  if( !PySlice_Check(slice) ) {
7259  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7260  return;
7261  }
7262  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7263  std::vector< double,std::allocator< double > >::difference_type id = i;
7264  std::vector< double,std::allocator< double > >::difference_type jd = j;
7265  swig::delslice(self, id, jd, step);
7266  }
7267 SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
7268  return *(swig::cgetpos(self, i));
7269  }
7270 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
7271  *(swig::getpos(self,i)) = x;
7272  }
7273 SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
7274  if (self->size() == 0)
7275  throw std::out_of_range("pop from empty container");
7276  std::vector< double,std::allocator< double > >::value_type x = self->back();
7277  self->pop_back();
7278  return x;
7279  }
7280 SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
7281  self->push_back(x);
7282  }
7283 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
7284 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
7285 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
7286 SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
7287 
7288  namespace swig {
7289  template <> struct traits<std::vector< int, std::allocator< int > > > {
7290  typedef pointer_category category;
7291  static const char* type_name() {
7292  return "std::vector<" "int" "," "std::allocator< int >" " >";
7293  }
7294  };
7295  }
7296 
7297 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
7298  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
7299  }
7300 SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
7301  return !(self->empty());
7302  }
7303 SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
7304  return !(self->empty());
7305  }
7306 SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
7307  return self->size();
7308  }
7309 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
7310  return swig::getslice(self, i, j, 1);
7311  }
7312 SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
7313  swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
7314  }
7315 SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
7316  swig::setslice(self, i, j, 1, v);
7317  }
7318 SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
7319  swig::delslice(self, i, j, 1);
7320  }
7321 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
7322  swig::erase(self, swig::getpos(self, i));
7323  }
7324 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
7325  Py_ssize_t i, j, step;
7326  if( !PySlice_Check(slice) ) {
7327  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7328  return NULL;
7329  }
7330  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7331  std::vector< int,std::allocator< int > >::difference_type id = i;
7332  std::vector< int,std::allocator< int > >::difference_type jd = j;
7333  return swig::getslice(self, id, jd, step);
7334  }
7335 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
7336  Py_ssize_t i, j, step;
7337  if( !PySlice_Check(slice) ) {
7338  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7339  return;
7340  }
7341  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7342  std::vector< int,std::allocator< int > >::difference_type id = i;
7343  std::vector< int,std::allocator< int > >::difference_type jd = j;
7344  swig::setslice(self, id, jd, step, v);
7345  }
7346 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
7347  Py_ssize_t i, j, step;
7348  if( !PySlice_Check(slice) ) {
7349  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7350  return;
7351  }
7352  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7353  std::vector< int,std::allocator< int > >::difference_type id = i;
7354  std::vector< int,std::allocator< int > >::difference_type jd = j;
7355  swig::delslice(self, id, jd, step);
7356  }
7357 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
7358  Py_ssize_t i, j, step;
7359  if( !PySlice_Check(slice) ) {
7360  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7361  return;
7362  }
7363  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7364  std::vector< int,std::allocator< int > >::difference_type id = i;
7365  std::vector< int,std::allocator< int > >::difference_type jd = j;
7366  swig::delslice(self, id, jd, step);
7367  }
7368 SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
7369  return *(swig::cgetpos(self, i));
7370  }
7371 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
7372  *(swig::getpos(self,i)) = x;
7373  }
7374 SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
7375  if (self->size() == 0)
7376  throw std::out_of_range("pop from empty container");
7377  std::vector< int,std::allocator< int > >::value_type x = self->back();
7378  self->pop_back();
7379  return x;
7380  }
7381 SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
7382  self->push_back(x);
7383  }
7384 SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos){ return self->erase(pos); }
7385 SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_1(std::vector< int > *self,std::vector< int >::iterator first,std::vector< int >::iterator last){ return self->erase(first, last); }
7386 SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::value_type const &x){ return self->insert(pos, x); }
7387 SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }
7388 
7389  namespace swig {
7390  template <> struct traits<std::vector< std::string, std::allocator< std::string > > > {
7391  typedef pointer_category category;
7392  static const char* type_name() {
7393  return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
7394  }
7395  };
7396  }
7397 
7398 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_string_Sg__iterator(std::vector< std::string > *self,PyObject **PYTHON_SELF){
7399  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
7400  }
7401 SWIGINTERN bool std_vector_Sl_std_string_Sg____nonzero__(std::vector< std::string > const *self){
7402  return !(self->empty());
7403  }
7404 SWIGINTERN bool std_vector_Sl_std_string_Sg____bool__(std::vector< std::string > const *self){
7405  return !(self->empty());
7406  }
7407 SWIGINTERN std::vector< std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector< std::string > const *self){
7408  return self->size();
7409  }
7410 SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
7411  return swig::getslice(self, i, j, 1);
7412  }
7413 SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
7414  swig::setslice(self, i, j, 1, std::vector< std::string,std::allocator< std::string > >());
7415  }
7416 SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v){
7417  swig::setslice(self, i, j, 1, v);
7418  }
7419 SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
7420  swig::delslice(self, i, j, 1);
7421  }
7422 SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
7423  swig::erase(self, swig::getpos(self, i));
7424  }
7425 SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
7426  Py_ssize_t i, j, step;
7427  if( !PySlice_Check(slice) ) {
7428  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7429  return NULL;
7430  }
7431  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7432  std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
7433  std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
7434  return swig::getslice(self, id, jd, step);
7435  }
7436 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
7437  Py_ssize_t i, j, step;
7438  if( !PySlice_Check(slice) ) {
7439  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7440  return;
7441  }
7442  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7443  std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
7444  std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
7445  swig::setslice(self, id, jd, step, v);
7446  }
7447 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
7448  Py_ssize_t i, j, step;
7449  if( !PySlice_Check(slice) ) {
7450  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7451  return;
7452  }
7453  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7454  std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
7455  std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
7456  swig::delslice(self, id, jd, step);
7457  }
7458 SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
7459  Py_ssize_t i, j, step;
7460  if( !PySlice_Check(slice) ) {
7461  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7462  return;
7463  }
7464  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7465  std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
7466  std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
7467  swig::delslice(self, id, jd, step);
7468  }
7469 SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
7470  return *(swig::cgetpos(self, i));
7471  }
7472 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
7473  *(swig::getpos(self,i)) = x;
7474  }
7475 SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
7476  if (self->size() == 0)
7477  throw std::out_of_range("pop from empty container");
7478  std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
7479  self->pop_back();
7480  return x;
7481  }
7482 SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
7483  self->push_back(x);
7484  }
7485 SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos){ return self->erase(pos); }
7486 SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator first,std::vector< std::string >::iterator last){ return self->erase(first, last); }
7487 SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__insert__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::value_type const &x){ return self->insert(pos, x); }
7488 SWIGINTERN void std_vector_Sl_std_string_Sg__insert__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::size_type n,std::vector< std::string >::value_type const &x){ self->insert(pos, n, x); }
7489 
7490  namespace swig {
7491  template <> struct traits<std::vector< std::pair< int,int >, std::allocator< std::pair< int,int > > > > {
7492  typedef pointer_category category;
7493  static const char* type_name() {
7494  return "std::vector<" "std::pair< int,int >" "," "std::allocator< std::pair< int,int > >" " >";
7495  }
7496  };
7497  }
7498 
7499 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__iterator(std::vector< std::pair< int,int > > *self,PyObject **PYTHON_SELF){
7500  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
7501  }
7502 SWIGINTERN bool std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____nonzero__(std::vector< std::pair< int,int > > const *self){
7503  return !(self->empty());
7504  }
7505 SWIGINTERN bool std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____bool__(std::vector< std::pair< int,int > > const *self){
7506  return !(self->empty());
7507  }
7508 SWIGINTERN std::vector< std::pair< int,int > >::size_type std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____len__(std::vector< std::pair< int,int > > const *self){
7509  return self->size();
7510  }
7511 SWIGINTERN std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____getslice__(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i,std::vector< std::pair< int,int > >::difference_type j){
7512  return swig::getslice(self, i, j, 1);
7513  }
7514 SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setslice____SWIG_0(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i,std::vector< std::pair< int,int > >::difference_type j){
7515  swig::setslice(self, i, j, 1, std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >());
7516  }
7517 SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setslice____SWIG_1(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i,std::vector< std::pair< int,int > >::difference_type j,std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &v){
7518  swig::setslice(self, i, j, 1, v);
7519  }
7520 SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____delslice__(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i,std::vector< std::pair< int,int > >::difference_type j){
7521  swig::delslice(self, i, j, 1);
7522  }
7523 SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i){
7524  swig::erase(self, swig::getpos(self, i));
7525  }
7526 SWIGINTERN std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< int,int > > *self,PySliceObject *slice){
7527  Py_ssize_t i, j, step;
7528  if( !PySlice_Check(slice) ) {
7529  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7530  return NULL;
7531  }
7532  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7533  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type id = i;
7534  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type jd = j;
7535  return swig::getslice(self, id, jd, step);
7536  }
7537 SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< int,int > > *self,PySliceObject *slice,std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &v){
7538  Py_ssize_t i, j, step;
7539  if( !PySlice_Check(slice) ) {
7540  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7541  return;
7542  }
7543  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7544  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type id = i;
7545  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type jd = j;
7546  swig::setslice(self, id, jd, step, v);
7547  }
7548 SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< int,int > > *self,PySliceObject *slice){
7549  Py_ssize_t i, j, step;
7550  if( !PySlice_Check(slice) ) {
7551  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7552  return;
7553  }
7554  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7555  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type id = i;
7556  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type jd = j;
7557  swig::delslice(self, id, jd, step);
7558  }
7559 SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< int,int > > *self,PySliceObject *slice){
7560  Py_ssize_t i, j, step;
7561  if( !PySlice_Check(slice) ) {
7562  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7563  return;
7564  }
7565  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7566  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type id = i;
7567  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type jd = j;
7568  swig::delslice(self, id, jd, step);
7569  }
7570 SWIGINTERN std::vector< std::pair< int,int > >::value_type const &std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____getitem____SWIG_1(std::vector< std::pair< int,int > > const *self,std::vector< std::pair< int,int > >::difference_type i){
7571  return *(swig::cgetpos(self, i));
7572  }
7573 SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_2(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i,std::vector< std::pair< int,int > >::value_type const &x){
7574  *(swig::getpos(self,i)) = x;
7575  }
7576 SWIGINTERN std::vector< std::pair< int,int > >::value_type std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__pop(std::vector< std::pair< int,int > > *self){
7577  if (self->size() == 0)
7578  throw std::out_of_range("pop from empty container");
7579  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::value_type x = self->back();
7580  self->pop_back();
7581  return x;
7582  }
7583 SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__append(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::value_type const &x){
7584  self->push_back(x);
7585  }
7586 SWIGINTERN std::vector< std::pair< int,int > >::iterator std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_0(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::iterator pos){ return self->erase(pos); }
7587 SWIGINTERN std::vector< std::pair< int,int > >::iterator std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_1(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::iterator first,std::vector< std::pair< int,int > >::iterator last){ return self->erase(first, last); }
7588 SWIGINTERN std::vector< std::pair< int,int > >::iterator std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__insert__SWIG_0(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::iterator pos,std::vector< std::pair< int,int > >::value_type const &x){ return self->insert(pos, x); }
7589 SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__insert__SWIG_1(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::iterator pos,std::vector< std::pair< int,int > >::size_type n,std::vector< std::pair< int,int > >::value_type const &x){ self->insert(pos, n, x); }
7590 
7591  namespace swig {
7592  template <> struct traits<std::vector< std::vector< int,std::allocator< int > >, std::allocator< std::vector< int,std::allocator< int > > > > > {
7593  typedef pointer_category category;
7594  static const char* type_name() {
7595  return "std::vector<" "std::vector< int,std::allocator< int > >" "," "std::allocator< std::vector< int,std::allocator< int > > >" " >";
7596  }
7597  };
7598  }
7599 
7600 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_int_Sg__Sg__iterator(std::vector< std::vector< int > > *self,PyObject **PYTHON_SELF){
7601  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
7602  }
7603 SWIGINTERN bool std_vector_Sl_std_vector_Sl_int_Sg__Sg____nonzero__(std::vector< std::vector< int > > const *self){
7604  return !(self->empty());
7605  }
7606 SWIGINTERN bool std_vector_Sl_std_vector_Sl_int_Sg__Sg____bool__(std::vector< std::vector< int > > const *self){
7607  return !(self->empty());
7608  }
7609 SWIGINTERN std::vector< std::vector< int > >::size_type std_vector_Sl_std_vector_Sl_int_Sg__Sg____len__(std::vector< std::vector< int > > const *self){
7610  return self->size();
7611  }
7612 SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getslice__(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j){
7613  return swig::getslice(self, i, j, 1);
7614  }
7615 SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j){
7616  swig::setslice(self, i, j, 1, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >());
7617  }
7618 SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
7619  swig::setslice(self, i, j, 1, v);
7620  }
7621 SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j){
7622  swig::delslice(self, i, j, 1);
7623  }
7624 SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i){
7625  swig::erase(self, swig::getpos(self, i));
7626  }
7627 SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice){
7628  Py_ssize_t i, j, step;
7629  if( !PySlice_Check(slice) ) {
7630  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7631  return NULL;
7632  }
7633  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7634  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
7635  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
7636  return swig::getslice(self, id, jd, step);
7637  }
7638 SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
7639  Py_ssize_t i, j, step;
7640  if( !PySlice_Check(slice) ) {
7641  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7642  return;
7643  }
7644  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7645  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
7646  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
7647  swig::setslice(self, id, jd, step, v);
7648  }
7649 SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
7650  Py_ssize_t i, j, step;
7651  if( !PySlice_Check(slice) ) {
7652  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7653  return;
7654  }
7655  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7656  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
7657  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
7658  swig::delslice(self, id, jd, step);
7659  }
7660 SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
7661  Py_ssize_t i, j, step;
7662  if( !PySlice_Check(slice) ) {
7663  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7664  return;
7665  }
7666  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7667  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
7668  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
7669  swig::delslice(self, id, jd, step);
7670  }
7671 SWIGINTERN std::vector< std::vector< int > >::value_type const &std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< int > > const *self,std::vector< std::vector< int > >::difference_type i){
7672  return *(swig::cgetpos(self, i));
7673  }
7674 SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::value_type const &x){
7675  *(swig::getpos(self,i)) = x;
7676  }
7677 SWIGINTERN std::vector< std::vector< int > >::value_type std_vector_Sl_std_vector_Sl_int_Sg__Sg__pop(std::vector< std::vector< int > > *self){
7678  if (self->size() == 0)
7679  throw std::out_of_range("pop from empty container");
7680  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::value_type x = self->back();
7681  self->pop_back();
7682  return x;
7683  }
7684 SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__append(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::value_type const &x){
7685  self->push_back(x);
7686  }
7687 SWIGINTERN std::vector< std::vector< int > >::iterator std_vector_Sl_std_vector_Sl_int_Sg__Sg__erase__SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator pos){ return self->erase(pos); }
7688 SWIGINTERN std::vector< std::vector< int > >::iterator std_vector_Sl_std_vector_Sl_int_Sg__Sg__erase__SWIG_1(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator first,std::vector< std::vector< int > >::iterator last){ return self->erase(first, last); }
7689 SWIGINTERN std::vector< std::vector< int > >::iterator std_vector_Sl_std_vector_Sl_int_Sg__Sg__insert__SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator pos,std::vector< std::vector< int > >::value_type const &x){ return self->insert(pos, x); }
7690 SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__insert__SWIG_1(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator pos,std::vector< std::vector< int > >::size_type n,std::vector< std::vector< int > >::value_type const &x){ self->insert(pos, n, x); }
7691 
7692  namespace swig {
7693  template <> struct traits<std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >, std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > > {
7694  typedef pointer_category category;
7695  static const char* type_name() {
7696  return "std::vector<" "std::vector< std::complex< double >,std::allocator< std::complex< double > > >" "," "std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >" " >";
7697  }
7698  };
7699  }
7700 
7701 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__iterator(std::vector< std::vector< std::complex< double > > > *self,PyObject **PYTHON_SELF){
7702  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
7703  }
7704 SWIGINTERN bool std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____nonzero__(std::vector< std::vector< std::complex< double > > > const *self){
7705  return !(self->empty());
7706  }
7707 SWIGINTERN bool std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____bool__(std::vector< std::vector< std::complex< double > > > const *self){
7708  return !(self->empty());
7709  }
7710 SWIGINTERN std::vector< std::vector< std::complex< double > > >::size_type std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____len__(std::vector< std::vector< std::complex< double > > > const *self){
7711  return self->size();
7712  }
7713 SWIGINTERN std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____getslice__(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i,std::vector< std::vector< std::complex< double > > >::difference_type j){
7714  return swig::getslice(self, i, j, 1);
7715  }
7716 SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_0(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i,std::vector< std::vector< std::complex< double > > >::difference_type j){
7717  swig::setslice(self, i, j, 1, std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >());
7718  }
7719 SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_1(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i,std::vector< std::vector< std::complex< double > > >::difference_type j,std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &v){
7720  swig::setslice(self, i, j, 1, v);
7721  }
7722 SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____delslice__(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i,std::vector< std::vector< std::complex< double > > >::difference_type j){
7723  swig::delslice(self, i, j, 1);
7724  }
7725 SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____delitem____SWIG_0(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i){
7726  swig::erase(self, swig::getpos(self, i));
7727  }
7728 SWIGINTERN std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____getitem____SWIG_0(std::vector< std::vector< std::complex< double > > > *self,PySliceObject *slice){
7729  Py_ssize_t i, j, step;
7730  if( !PySlice_Check(slice) ) {
7731  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7732  return NULL;
7733  }
7734  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7735  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type id = i;
7736  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type jd = j;
7737  return swig::getslice(self, id, jd, step);
7738  }
7739 SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_0(std::vector< std::vector< std::complex< double > > > *self,PySliceObject *slice,std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &v){
7740  Py_ssize_t i, j, step;
7741  if( !PySlice_Check(slice) ) {
7742  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7743  return;
7744  }
7745  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7746  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type id = i;
7747  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type jd = j;
7748  swig::setslice(self, id, jd, step, v);
7749  }
7750 SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_1(std::vector< std::vector< std::complex< double > > > *self,PySliceObject *slice){
7751  Py_ssize_t i, j, step;
7752  if( !PySlice_Check(slice) ) {
7753  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7754  return;
7755  }
7756  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7757  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type id = i;
7758  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type jd = j;
7759  swig::delslice(self, id, jd, step);
7760  }
7761 SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____delitem____SWIG_1(std::vector< std::vector< std::complex< double > > > *self,PySliceObject *slice){
7762  Py_ssize_t i, j, step;
7763  if( !PySlice_Check(slice) ) {
7764  SWIG_Error(SWIG_TypeError, "Slice object expected.");
7765  return;
7766  }
7767  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
7768  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type id = i;
7769  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type jd = j;
7770  swig::delslice(self, id, jd, step);
7771  }
7772 SWIGINTERN std::vector< std::vector< std::complex< double > > >::value_type const &std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____getitem____SWIG_1(std::vector< std::vector< std::complex< double > > > const *self,std::vector< std::vector< std::complex< double > > >::difference_type i){
7773  return *(swig::cgetpos(self, i));
7774  }
7775 SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_2(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i,std::vector< std::vector< std::complex< double > > >::value_type const &x){
7776  *(swig::getpos(self,i)) = x;
7777  }
7778 SWIGINTERN std::vector< std::vector< std::complex< double > > >::value_type std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__pop(std::vector< std::vector< std::complex< double > > > *self){
7779  if (self->size() == 0)
7780  throw std::out_of_range("pop from empty container");
7781  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::value_type x = self->back();
7782  self->pop_back();
7783  return x;
7784  }
7785 SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__append(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::value_type const &x){
7786  self->push_back(x);
7787  }
7788 SWIGINTERN std::vector< std::vector< std::complex< double > > >::iterator std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__erase__SWIG_0(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::iterator pos){ return self->erase(pos); }
7789 SWIGINTERN std::vector< std::vector< std::complex< double > > >::iterator std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__erase__SWIG_1(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::iterator first,std::vector< std::vector< std::complex< double > > >::iterator last){ return self->erase(first, last); }
7790 SWIGINTERN std::vector< std::vector< std::complex< double > > >::iterator std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__insert__SWIG_0(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::iterator pos,std::vector< std::vector< std::complex< double > > >::value_type const &x){ return self->insert(pos, x); }
7791 SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__insert__SWIG_1(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::iterator pos,std::vector< std::vector< std::complex< double > > >::size_type n,std::vector< std::vector< std::complex< double > > >::value_type const &x){ self->insert(pos, n, x); }
7792 
7793 #include <assert.h>
7794 static int VEC4_ERROR(0), EVENT_ERROR(0), BEAMPARTICLE_ERROR(0),
7795  COLCONFIG_ERROR(0);
7796 
7797 
7798 #include "Pythia8/Pythia.h"
7799 using namespace Pythia8;
7800 #include "Pythia8/Analysis.h"
7801 #include "Pythia8/Basics.h"
7802 #include "Pythia8/BeamParticle.h"
7803 #include "Pythia8/BeamRemnants.h"
7804 #include "Pythia8/BeamShape.h"
7805 #include "Pythia8/BoseEinstein.h"
7806 #include "Pythia8/ColourReconnection.h"
7807 #include "Pythia8/ColourTracing.h"
7808 #include "Pythia8/DeuteronProduction.h"
7809 #include "Pythia8/Event.h"
7810 #include "Pythia8/FragmentationFlavZpT.h"
7811 #include "Pythia8/FragmentationSystems.h"
7812 #include "Pythia8/GammaKinematics.h"
7813 #include "Pythia8/HadronLevel.h"
7814 #include "Pythia8/HadronScatter.h"
7815 #include "Pythia8/HardDiffraction.h"
7816 #include "Pythia8/HeavyIons.h"
7817 #include "Pythia8/HelicityBasics.h"
7818 #include "Pythia8/HelicityMatrixElements.h"
7819 #include "Pythia8/HiddenValleyFragmentation.h"
7820 #include "Pythia8/History.h"
7821 #include "Pythia8/HIUserHooks.h"
7822 #include "Pythia8/Info.h"
7823 #include "Pythia8/JunctionSplitting.h"
7824 #include "Pythia8/LesHouches.h"
7825 #include "Pythia8/LHEF3.h"
7826 #include "Pythia8/Merging.h"
7827 #include "Pythia8/MergingHooks.h"
7828 #include "Pythia8/MiniStringFragmentation.h"
7829 #include "Pythia8/MultipartonInteractions.h"
7830 #include "Pythia8/ParticleData.h"
7831 #include "Pythia8/ParticleDecays.h"
7832 #include "Pythia8/PartonDistributions.h"
7833 #include "Pythia8/PartonLevel.h"
7834 #include "Pythia8/PartonSystems.h"
7835 #include "Pythia8/PartonVertex.h"
7836 #include "Pythia8/PhaseSpace.h"
7837 #include "Pythia8Plugins/aMCatNLOHooks.h"
7838 #include "Pythia8Plugins/ColourReconnectionHooks.h"
7839 #include "Pythia8Plugins/CombineMatchingInput.h"
7840 #include "Pythia8Plugins/GeneratorInput.h"
7841 #include "Pythia8Plugins/JetMatching.h"
7842 #include "Pythia8Plugins/LHAHelaconia.h"
7843 #include "Pythia8Plugins/LHAMadgraph.h"
7844 #include "Pythia8Plugins/PowhegHooks.h"
7845 #include "Pythia8Plugins/PowhegProcs.h"
7846 #include "Pythia8Plugins/ProgressLog.h"
7847 #include "Pythia8/ProcessContainer.h"
7848 #include "Pythia8/ProcessLevel.h"
7849 #include "Pythia8/PythiaComplex.h"
7850 #include "Pythia8/Pythia.h"
7851 #include "Pythia8/PythiaStdlib.h"
7852 #include "Pythia8/ResonanceDecays.h"
7853 #include "Pythia8/ResonanceWidthsDM.h"
7854 #include "Pythia8/ResonanceWidths.h"
7855 #include "Pythia8/RHadrons.h"
7856 #include "Pythia8/Ropewalk.h"
7857 #include "Pythia8/Settings.h"
7858 #include "Pythia8/SigmaCompositeness.h"
7859 #include "Pythia8/SigmaDM.h"
7860 #include "Pythia8/SigmaEW.h"
7861 #include "Pythia8/SigmaExtraDim.h"
7862 #include "Pythia8/SigmaGeneric.h"
7863 #include "Pythia8/SigmaHiggs.h"
7864 #include "Pythia8/SigmaLeftRightSym.h"
7865 #include "Pythia8/SigmaLeptoquark.h"
7866 #include "Pythia8/SigmaNewGaugeBosons.h"
7867 #include "Pythia8/SigmaOnia.h"
7868 #include "Pythia8/SigmaProcess.h"
7869 #include "Pythia8/SigmaQCD.h"
7870 #include "Pythia8/SigmaSUSY.h"
7871 #include "Pythia8/SigmaTotal.h"
7872 #include "Pythia8/SimpleSpaceShower.h"
7873 #include "Pythia8/SimpleTimeShower.h"
7874 #include "Pythia8/SimpleWeakShowerMEs.h"
7875 #include "Pythia8/SLHAinterface.h"
7876 #include "Pythia8/SpaceShower.h"
7877 #include "Pythia8/StandardModel.h"
7878 #include "Pythia8/Streams.h"
7879 #include "Pythia8/StringFragmentation.h"
7880 #include "Pythia8/StringLength.h"
7881 #include "Pythia8/SusyCouplings.h"
7882 #include "Pythia8/SusyLesHouches.h"
7883 #include "Pythia8/SusyResonanceWidths.h"
7884 #include "Pythia8/SusyWidthFunctions.h"
7885 #include "Pythia8/TauDecays.h"
7886 #include "Pythia8/TimeShower.h"
7887 #include "Pythia8/UserHooks.h"
7888 
7889 SWIGINTERN std::string Pythia8_Vec4___str__(Pythia8::Vec4 *self){
7890  std::ostringstream oss(std::ostringstream::out); oss << *(self);
7891  return oss.str();}
7892 SWIGINTERN double Pythia8_Vec4___getitem__(Pythia8::Vec4 *self,int i){
7893  if (i >= 4) {VEC4_ERROR = 1; return 0;} return (*(self))[i];}
7894 SWIGINTERN Pythia8::Vec4 Pythia8_Vec4___rmul__(Pythia8::Vec4 *self,double f){
7895  Pythia8::Vec4 v = *self; return f*v;}
7896 SWIGINTERN std::string Pythia8_RotBstMatrix___str__(Pythia8::RotBstMatrix *self){
7897  std::ostringstream oss(std::ostringstream::out); oss << *(self);
7898  return oss.str();}
7899 SWIGINTERN std::string Pythia8_Hist___str__(Pythia8::Hist *self){
7900  std::ostringstream oss(std::ostringstream::out); oss << *(self);
7901  return oss.str();}
7902 SWIGINTERN Pythia8::Hist Pythia8_Hist___radd__(Pythia8::Hist *self,double f){
7903  Pythia8::Hist h = *self; return f+h;}
7904 SWIGINTERN Pythia8::Hist Pythia8_Hist___rsub__(Pythia8::Hist *self,double f){
7905  Pythia8::Hist h = *self; return f-h;}
7906 SWIGINTERN Pythia8::Hist Pythia8_Hist___rmul__(Pythia8::Hist *self,double f){
7907  Pythia8::Hist h = *self; return f*h;}
7908 SWIGINTERN Pythia8::Hist Pythia8_Hist___rdiv__(Pythia8::Hist *self,double f){
7909  Pythia8::Hist h = *self; return f/h;}
7910 SWIGINTERN std::string Pythia8_XMLTag___str__(Pythia8::XMLTag *self){
7911  std::ostringstream oss(std::ostringstream::out); self->list(oss);
7912  return oss.str();}
7913 SWIGINTERN std::string Pythia8_LHAweights___str__(Pythia8::LHAweights *self){
7914  std::ostringstream oss(std::ostringstream::out); self->list(oss);
7915  return oss.str();}
7916 SWIGINTERN std::string Pythia8_LHAscales___str__(Pythia8::LHAscales *self){
7917  std::ostringstream oss(std::ostringstream::out); self->list(oss);
7918  return oss.str();}
7919 SWIGINTERN std::string Pythia8_LHAgenerator___str__(Pythia8::LHAgenerator *self){
7920  std::ostringstream oss(std::ostringstream::out); self->list(oss);
7921  return oss.str();}
7922 SWIGINTERN std::string Pythia8_LHAwgt___str__(Pythia8::LHAwgt *self){
7923  std::ostringstream oss(std::ostringstream::out); self->list(oss);
7924  return oss.str();}
7925 SWIGINTERN std::string Pythia8_LHAweight___str__(Pythia8::LHAweight *self){
7926  std::ostringstream oss(std::ostringstream::out); self->list(oss);
7927  return oss.str();}
7928 SWIGINTERN std::string Pythia8_LHAweightgroup___str__(Pythia8::LHAweightgroup *self){
7929  std::ostringstream oss(std::ostringstream::out); self->list(oss);
7930  return oss.str();}
7931 SWIGINTERN std::string Pythia8_LHArwgt___str__(Pythia8::LHArwgt *self){
7932  std::ostringstream oss(std::ostringstream::out); self->list(oss);
7933  return oss.str();}
7934 SWIGINTERN std::string Pythia8_LHAinitrwgt___str__(Pythia8::LHAinitrwgt *self){
7935  std::ostringstream oss(std::ostringstream::out); self->list(oss);
7936  return oss.str();}
7937 SWIGINTERN std::string Pythia8_PartonSystems___str__(Pythia8::PartonSystems *self){
7938  std::streambuf* old = cout.rdbuf();
7939  std::ostringstream oss(std::ostringstream::out);
7940  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
7941  return oss.str();}
7942 
7943 SWIGINTERNINLINE PyObject*
7944  SWIG_From_unsigned_SS_int (unsigned int value)
7945 {
7946  return PyInt_FromSize_t((size_t) value);
7947 }
7948 
7949 SWIGINTERN std::string Pythia8_Info___str__(Pythia8::Info *self){
7950  std::streambuf* old = cout.rdbuf();
7951  std::ostringstream oss(std::ostringstream::out);
7952  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
7953  return oss.str();}
7954 SWIGINTERN std::string Pythia8_ParticleData___str__(Pythia8::ParticleData *self){
7955  std::streambuf* old = cout.rdbuf();
7956  std::ostringstream oss(std::ostringstream::out);
7957  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
7958  return oss.str();}
7959 SWIGINTERN std::string Pythia8_Event___str__(Pythia8::Event *self){
7960  std::streambuf* old = cout.rdbuf();
7961  std::ostringstream oss(std::ostringstream::out);
7962  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
7963  return oss.str();}
7964 SWIGINTERN Pythia8::Particle *Pythia8_Event___getitem__(Pythia8::Event *self,int i){
7965  if (i >= self->size()) {EVENT_ERROR = 1; return 0;}
7966  return &(*(self))[i];}
7967 SWIGINTERN std::string Pythia8_ColConfig___str__(Pythia8::ColConfig *self){
7968  std::streambuf* old = cout.rdbuf();
7969  std::ostringstream oss(std::ostringstream::out);
7970  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
7971  return oss.str();}
7972 SWIGINTERN Pythia8::ColSinglet *Pythia8_ColConfig___getitem__(Pythia8::ColConfig *self,int i){
7973  if (i >= self->size()) {COLCONFIG_ERROR = 1; return 0;}
7974  return &(*(self))[i];}
7975 SWIGINTERN std::string Pythia8_Wave4___str__(Pythia8::Wave4 *self){
7976  std::ostringstream oss(std::ostringstream::out); oss << *(self);
7977  return oss.str();}
7978 SWIGINTERN Pythia8::Wave4 Pythia8_Wave4___rmul____SWIG_0(Pythia8::Wave4 *self,std::complex< double > s){
7979  Pythia8::Wave4 w = *self; return s*w;}
7980 SWIGINTERN Pythia8::Wave4 Pythia8_Wave4___rmul____SWIG_1(Pythia8::Wave4 *self,double s){
7981  Pythia8::Wave4 w = *self; return s*w;}
7982 SWIGINTERN Pythia8::Wave4 Pythia8_Wave4___mul____SWIG_3(Pythia8::Wave4 *self,Pythia8::GammaMatrix g){
7983  Pythia8::Wave4 w = *self; return w*g;}
7984 SWIGINTERN std::string Pythia8_GammaMatrix___str__(Pythia8::GammaMatrix *self){
7985  std::ostringstream oss(std::ostringstream::out); oss << *(self);
7986  return oss.str();}
7987 SWIGINTERN Pythia8::GammaMatrix Pythia8_GammaMatrix___rmul__(Pythia8::GammaMatrix *self,std::complex< double > s){
7988  Pythia8::GammaMatrix g = *self; return s*g;}
7989 SWIGINTERN Pythia8::GammaMatrix Pythia8_GammaMatrix___rsub__(Pythia8::GammaMatrix *self,std::complex< double > s){
7990  Pythia8::GammaMatrix g = *self; return s-g;}
7991 SWIGINTERN Pythia8::GammaMatrix Pythia8_GammaMatrix___radd__(Pythia8::GammaMatrix *self,std::complex< double > s){
7992  Pythia8::GammaMatrix g = *self; return s+g;}
7993 
7994 SWIGINTERNINLINE PyObject *
7995 SWIG_FromCharPtr(const char *cptr)
7996 {
7997  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
7998 }
7999 
8000 
8001 size_t
8002 SWIG_strnlen(const char* s, size_t maxlen)
8003 {
8004  const char *p;
8005  for (p = s; maxlen-- && *p; p++)
8006  ;
8007  return p - s;
8008 }
8009 
8010 SWIGINTERN std::string Pythia8_Sphericity___str__(Pythia8::Sphericity *self){
8011  std::streambuf* old = cout.rdbuf();
8012  std::ostringstream oss(std::ostringstream::out);
8013  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8014  return oss.str();}
8015 SWIGINTERN std::string Pythia8_Thrust___str__(Pythia8::Thrust *self){
8016  std::streambuf* old = cout.rdbuf();
8017  std::ostringstream oss(std::ostringstream::out);
8018  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8019  return oss.str();}
8020 SWIGINTERN std::string Pythia8_ClusterJet___str__(Pythia8::ClusterJet *self){
8021  std::streambuf* old = cout.rdbuf();
8022  std::ostringstream oss(std::ostringstream::out);
8023  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8024  return oss.str();}
8025 SWIGINTERN std::string Pythia8_CellJet___str__(Pythia8::CellJet *self){
8026  std::streambuf* old = cout.rdbuf();
8027  std::ostringstream oss(std::ostringstream::out);
8028  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8029  return oss.str();}
8030 SWIGINTERN std::string Pythia8_SlowJet___str__(Pythia8::SlowJet *self){
8031  std::streambuf* old = cout.rdbuf();
8032  std::ostringstream oss(std::ostringstream::out);
8033  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8034  return oss.str();}
8035 SWIGINTERN std::string Pythia8_BeamParticle___str__(Pythia8::BeamParticle *self){
8036  std::streambuf* old = cout.rdbuf();
8037  std::ostringstream oss(std::ostringstream::out);
8038  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8039  return oss.str();}
8040 SWIGINTERN Pythia8::ResolvedParton *Pythia8_BeamParticle___getitem__(Pythia8::BeamParticle *self,int i){
8041  if (i >= self->size()) {
8042  BEAMPARTICLE_ERROR = 1; return 0;} return &(*(self))[i];}
8043 SWIGINTERN std::string Pythia8_HardProcess___str__(Pythia8::HardProcess *self){
8044  std::streambuf* old = cout.rdbuf();
8045  std::ostringstream oss(std::ostringstream::out);
8046  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8047  return oss.str();}
8048 SWIGINTERN std::string Pythia8_SpaceShower___str__(Pythia8::SpaceShower *self){
8049  std::streambuf* old = cout.rdbuf();
8050  std::ostringstream oss(std::ostringstream::out);
8051  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8052  return oss.str();}
8053 SWIGINTERN std::string Pythia8_TimeShower___str__(Pythia8::TimeShower *self){
8054  std::streambuf* old = cout.rdbuf();
8055  std::ostringstream oss(std::ostringstream::out);
8056  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8057  return oss.str();}
8058 SWIGINTERN std::string Pythia8_ColourDipole___str__(Pythia8::ColourDipole *self){
8059  std::streambuf* old = cout.rdbuf();
8060  std::ostringstream oss(std::ostringstream::out);
8061  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8062  return oss.str();}
8063 SWIGINTERN std::string Pythia8_ColourJunction___str__(Pythia8::ColourJunction *self){
8064  std::streambuf* old = cout.rdbuf();
8065  std::ostringstream oss(std::ostringstream::out);
8066  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8067  return oss.str();}
8068 SWIGINTERN std::string Pythia8_Clustering___str__(Pythia8::Clustering *self){
8069  std::streambuf* old = cout.rdbuf();
8070  std::ostringstream oss(std::ostringstream::out);
8071  cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
8072  return oss.str();}
8073 
8074  namespace swig {
8075  template <> struct traits< Pythia8::Flag > {
8076  typedef pointer_category category;
8077  static const char* type_name() { return"Pythia8::Flag"; }
8078  };
8079  }
8080 
8081 
8082  namespace swig {
8083  template <> struct traits<std::pair< std::string, Pythia8::Flag > > {
8084  typedef pointer_category category;
8085  static const char* type_name() {
8086  return "std::pair<" "std::string" "," "Pythia8::Flag" " >";
8087  }
8088  };
8089  }
8090 
8091 
8092  namespace swig {
8093  template <> struct traits<std::map< std::string, Pythia8::Flag, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::Flag > > > > {
8094  typedef pointer_category category;
8095  static const char* type_name() {
8096  return "std::map<" "std::string" "," "Pythia8::Flag" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::Flag > >" " >";
8097  }
8098  };
8099  }
8100 
8101 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__iterator(std::map< std::string,Pythia8::Flag > *self,PyObject **PYTHON_SELF){
8102  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8103  }
8104 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____nonzero__(std::map< std::string,Pythia8::Flag > const *self){
8105  return !(self->empty());
8106  }
8107 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____bool__(std::map< std::string,Pythia8::Flag > const *self){
8108  return !(self->empty());
8109  }
8110 SWIGINTERN std::map< std::string,Pythia8::Flag >::size_type std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____len__(std::map< std::string,Pythia8::Flag > const *self){
8111  return self->size();
8112  }
8113 SWIGINTERN std::map< std::string,Pythia8::Flag >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____getitem__(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::key_type const &key){
8114  std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::const_iterator i = self->find(key);
8115  if (i != self->end())
8116  return i->second;
8117  else
8118  throw std::out_of_range("key not found");
8119  }
8120 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____delitem__(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::key_type const &key){
8121  std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::iterator i = self->find(key);
8122  if (i != self->end())
8123  self->erase(i);
8124  else
8125  throw std::out_of_range("key not found");
8126  }
8127 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__has_key(std::map< std::string,Pythia8::Flag > const *self,std::map< std::string,Pythia8::Flag >::key_type const &key){
8128  std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::const_iterator i = self->find(key);
8129  return i != self->end();
8130  }
8131 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__keys(std::map< std::string,Pythia8::Flag > *self){
8132  std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type size = self->size();
8133  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8134  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8135  if (pysize < 0) {
8136  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8137  SWIG_PYTHON_THREAD_END_BLOCK;
8138  return NULL;
8139  }
8140  PyObject* keyList = PyList_New(pysize);
8141  std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::const_iterator i = self->begin();
8142  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8143  PyList_SET_ITEM(keyList, j, swig::from(i->first));
8144  }
8145  SWIG_PYTHON_THREAD_END_BLOCK;
8146  return keyList;
8147  }
8148 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__values(std::map< std::string,Pythia8::Flag > *self){
8149  std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type size = self->size();
8150  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8151  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8152  if (pysize < 0) {
8153  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8154  SWIG_PYTHON_THREAD_END_BLOCK;
8155  return NULL;
8156  }
8157  PyObject* valList = PyList_New(pysize);
8158  std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::const_iterator i = self->begin();
8159  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8160  PyList_SET_ITEM(valList, j, swig::from(i->second));
8161  }
8162  SWIG_PYTHON_THREAD_END_BLOCK;
8163  return valList;
8164  }
8165 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__items(std::map< std::string,Pythia8::Flag > *self){
8166  std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type size = self->size();
8167  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8168  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8169  if (pysize < 0) {
8170  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8171  SWIG_PYTHON_THREAD_END_BLOCK;
8172  return NULL;
8173  }
8174  PyObject* itemList = PyList_New(pysize);
8175  std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::const_iterator i = self->begin();
8176  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8177  PyList_SET_ITEM(itemList, j, swig::from(*i));
8178  }
8179  SWIG_PYTHON_THREAD_END_BLOCK;
8180  return itemList;
8181  }
8182 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____contains__(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::key_type const &key){
8183  return self->find(key) != self->end();
8184  }
8185 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__key_iterator(std::map< std::string,Pythia8::Flag > *self,PyObject **PYTHON_SELF){
8186  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8187  }
8188 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__value_iterator(std::map< std::string,Pythia8::Flag > *self,PyObject **PYTHON_SELF){
8189  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8190  }
8191 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::key_type const &key){
8192  self->erase(key);
8193  }
8194 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::key_type const &key,std::map< std::string,Pythia8::Flag >::mapped_type const &x){
8195  (*self)[key] = x;
8196  }
8197 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__asdict(std::map< std::string,Pythia8::Flag > *self){
8198  return swig::traits_from< std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > > >::asdict(*self);
8199  }
8200 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__erase__SWIG_1(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::iterator position){ self->erase(position); }
8201 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__erase__SWIG_2(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::iterator first,std::map< std::string,Pythia8::Flag >::iterator last){ self->erase(first, last); }
8202 
8203  namespace swig {
8204  template <> struct traits< Pythia8::Mode > {
8205  typedef pointer_category category;
8206  static const char* type_name() { return"Pythia8::Mode"; }
8207  };
8208  }
8209 
8210 
8211  namespace swig {
8212  template <> struct traits<std::pair< std::string, Pythia8::Mode > > {
8213  typedef pointer_category category;
8214  static const char* type_name() {
8215  return "std::pair<" "std::string" "," "Pythia8::Mode" " >";
8216  }
8217  };
8218  }
8219 
8220 
8221  namespace swig {
8222  template <> struct traits<std::map< std::string, Pythia8::Mode, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::Mode > > > > {
8223  typedef pointer_category category;
8224  static const char* type_name() {
8225  return "std::map<" "std::string" "," "Pythia8::Mode" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::Mode > >" " >";
8226  }
8227  };
8228  }
8229 
8230 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__iterator(std::map< std::string,Pythia8::Mode > *self,PyObject **PYTHON_SELF){
8231  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8232  }
8233 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____nonzero__(std::map< std::string,Pythia8::Mode > const *self){
8234  return !(self->empty());
8235  }
8236 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____bool__(std::map< std::string,Pythia8::Mode > const *self){
8237  return !(self->empty());
8238  }
8239 SWIGINTERN std::map< std::string,Pythia8::Mode >::size_type std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____len__(std::map< std::string,Pythia8::Mode > const *self){
8240  return self->size();
8241  }
8242 SWIGINTERN std::map< std::string,Pythia8::Mode >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____getitem__(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::key_type const &key){
8243  std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::const_iterator i = self->find(key);
8244  if (i != self->end())
8245  return i->second;
8246  else
8247  throw std::out_of_range("key not found");
8248  }
8249 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____delitem__(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::key_type const &key){
8250  std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::iterator i = self->find(key);
8251  if (i != self->end())
8252  self->erase(i);
8253  else
8254  throw std::out_of_range("key not found");
8255  }
8256 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__has_key(std::map< std::string,Pythia8::Mode > const *self,std::map< std::string,Pythia8::Mode >::key_type const &key){
8257  std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::const_iterator i = self->find(key);
8258  return i != self->end();
8259  }
8260 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__keys(std::map< std::string,Pythia8::Mode > *self){
8261  std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type size = self->size();
8262  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8263  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8264  if (pysize < 0) {
8265  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8266  SWIG_PYTHON_THREAD_END_BLOCK;
8267  return NULL;
8268  }
8269  PyObject* keyList = PyList_New(pysize);
8270  std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::const_iterator i = self->begin();
8271  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8272  PyList_SET_ITEM(keyList, j, swig::from(i->first));
8273  }
8274  SWIG_PYTHON_THREAD_END_BLOCK;
8275  return keyList;
8276  }
8277 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__values(std::map< std::string,Pythia8::Mode > *self){
8278  std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type size = self->size();
8279  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8280  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8281  if (pysize < 0) {
8282  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8283  SWIG_PYTHON_THREAD_END_BLOCK;
8284  return NULL;
8285  }
8286  PyObject* valList = PyList_New(pysize);
8287  std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::const_iterator i = self->begin();
8288  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8289  PyList_SET_ITEM(valList, j, swig::from(i->second));
8290  }
8291  SWIG_PYTHON_THREAD_END_BLOCK;
8292  return valList;
8293  }
8294 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__items(std::map< std::string,Pythia8::Mode > *self){
8295  std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type size = self->size();
8296  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8297  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8298  if (pysize < 0) {
8299  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8300  SWIG_PYTHON_THREAD_END_BLOCK;
8301  return NULL;
8302  }
8303  PyObject* itemList = PyList_New(pysize);
8304  std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::const_iterator i = self->begin();
8305  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8306  PyList_SET_ITEM(itemList, j, swig::from(*i));
8307  }
8308  SWIG_PYTHON_THREAD_END_BLOCK;
8309  return itemList;
8310  }
8311 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____contains__(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::key_type const &key){
8312  return self->find(key) != self->end();
8313  }
8314 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__key_iterator(std::map< std::string,Pythia8::Mode > *self,PyObject **PYTHON_SELF){
8315  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8316  }
8317 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__value_iterator(std::map< std::string,Pythia8::Mode > *self,PyObject **PYTHON_SELF){
8318  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8319  }
8320 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::key_type const &key){
8321  self->erase(key);
8322  }
8323 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::key_type const &key,std::map< std::string,Pythia8::Mode >::mapped_type const &x){
8324  (*self)[key] = x;
8325  }
8326 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__asdict(std::map< std::string,Pythia8::Mode > *self){
8327  return swig::traits_from< std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > > >::asdict(*self);
8328  }
8329 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__erase__SWIG_1(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::iterator position){ self->erase(position); }
8330 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__erase__SWIG_2(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::iterator first,std::map< std::string,Pythia8::Mode >::iterator last){ self->erase(first, last); }
8331 
8332  namespace swig {
8333  template <> struct traits< Pythia8::Parm > {
8334  typedef pointer_category category;
8335  static const char* type_name() { return"Pythia8::Parm"; }
8336  };
8337  }
8338 
8339 
8340  namespace swig {
8341  template <> struct traits<std::pair< std::string, Pythia8::Parm > > {
8342  typedef pointer_category category;
8343  static const char* type_name() {
8344  return "std::pair<" "std::string" "," "Pythia8::Parm" " >";
8345  }
8346  };
8347  }
8348 
8349 
8350  namespace swig {
8351  template <> struct traits<std::map< std::string, Pythia8::Parm, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::Parm > > > > {
8352  typedef pointer_category category;
8353  static const char* type_name() {
8354  return "std::map<" "std::string" "," "Pythia8::Parm" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::Parm > >" " >";
8355  }
8356  };
8357  }
8358 
8359 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__iterator(std::map< std::string,Pythia8::Parm > *self,PyObject **PYTHON_SELF){
8360  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8361  }
8362 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____nonzero__(std::map< std::string,Pythia8::Parm > const *self){
8363  return !(self->empty());
8364  }
8365 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____bool__(std::map< std::string,Pythia8::Parm > const *self){
8366  return !(self->empty());
8367  }
8368 SWIGINTERN std::map< std::string,Pythia8::Parm >::size_type std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____len__(std::map< std::string,Pythia8::Parm > const *self){
8369  return self->size();
8370  }
8371 SWIGINTERN std::map< std::string,Pythia8::Parm >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____getitem__(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::key_type const &key){
8372  std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::const_iterator i = self->find(key);
8373  if (i != self->end())
8374  return i->second;
8375  else
8376  throw std::out_of_range("key not found");
8377  }
8378 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____delitem__(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::key_type const &key){
8379  std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::iterator i = self->find(key);
8380  if (i != self->end())
8381  self->erase(i);
8382  else
8383  throw std::out_of_range("key not found");
8384  }
8385 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__has_key(std::map< std::string,Pythia8::Parm > const *self,std::map< std::string,Pythia8::Parm >::key_type const &key){
8386  std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::const_iterator i = self->find(key);
8387  return i != self->end();
8388  }
8389 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__keys(std::map< std::string,Pythia8::Parm > *self){
8390  std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type size = self->size();
8391  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8392  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8393  if (pysize < 0) {
8394  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8395  SWIG_PYTHON_THREAD_END_BLOCK;
8396  return NULL;
8397  }
8398  PyObject* keyList = PyList_New(pysize);
8399  std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::const_iterator i = self->begin();
8400  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8401  PyList_SET_ITEM(keyList, j, swig::from(i->first));
8402  }
8403  SWIG_PYTHON_THREAD_END_BLOCK;
8404  return keyList;
8405  }
8406 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__values(std::map< std::string,Pythia8::Parm > *self){
8407  std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type size = self->size();
8408  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8409  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8410  if (pysize < 0) {
8411  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8412  SWIG_PYTHON_THREAD_END_BLOCK;
8413  return NULL;
8414  }
8415  PyObject* valList = PyList_New(pysize);
8416  std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::const_iterator i = self->begin();
8417  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8418  PyList_SET_ITEM(valList, j, swig::from(i->second));
8419  }
8420  SWIG_PYTHON_THREAD_END_BLOCK;
8421  return valList;
8422  }
8423 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__items(std::map< std::string,Pythia8::Parm > *self){
8424  std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type size = self->size();
8425  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8426  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8427  if (pysize < 0) {
8428  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8429  SWIG_PYTHON_THREAD_END_BLOCK;
8430  return NULL;
8431  }
8432  PyObject* itemList = PyList_New(pysize);
8433  std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::const_iterator i = self->begin();
8434  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8435  PyList_SET_ITEM(itemList, j, swig::from(*i));
8436  }
8437  SWIG_PYTHON_THREAD_END_BLOCK;
8438  return itemList;
8439  }
8440 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____contains__(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::key_type const &key){
8441  return self->find(key) != self->end();
8442  }
8443 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__key_iterator(std::map< std::string,Pythia8::Parm > *self,PyObject **PYTHON_SELF){
8444  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8445  }
8446 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__value_iterator(std::map< std::string,Pythia8::Parm > *self,PyObject **PYTHON_SELF){
8447  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8448  }
8449 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::key_type const &key){
8450  self->erase(key);
8451  }
8452 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::key_type const &key,std::map< std::string,Pythia8::Parm >::mapped_type const &x){
8453  (*self)[key] = x;
8454  }
8455 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__asdict(std::map< std::string,Pythia8::Parm > *self){
8456  return swig::traits_from< std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > > >::asdict(*self);
8457  }
8458 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__erase__SWIG_1(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::iterator position){ self->erase(position); }
8459 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__erase__SWIG_2(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::iterator first,std::map< std::string,Pythia8::Parm >::iterator last){ self->erase(first, last); }
8460 
8461  namespace swig {
8462  template <> struct traits< Pythia8::Word > {
8463  typedef pointer_category category;
8464  static const char* type_name() { return"Pythia8::Word"; }
8465  };
8466  }
8467 
8468 
8469  namespace swig {
8470  template <> struct traits<std::pair< std::string, Pythia8::Word > > {
8471  typedef pointer_category category;
8472  static const char* type_name() {
8473  return "std::pair<" "std::string" "," "Pythia8::Word" " >";
8474  }
8475  };
8476  }
8477 
8478 
8479  namespace swig {
8480  template <> struct traits<std::map< std::string, Pythia8::Word, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::Word > > > > {
8481  typedef pointer_category category;
8482  static const char* type_name() {
8483  return "std::map<" "std::string" "," "Pythia8::Word" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::Word > >" " >";
8484  }
8485  };
8486  }
8487 
8488 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__iterator(std::map< std::string,Pythia8::Word > *self,PyObject **PYTHON_SELF){
8489  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8490  }
8491 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Word_Sg____nonzero__(std::map< std::string,Pythia8::Word > const *self){
8492  return !(self->empty());
8493  }
8494 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Word_Sg____bool__(std::map< std::string,Pythia8::Word > const *self){
8495  return !(self->empty());
8496  }
8497 SWIGINTERN std::map< std::string,Pythia8::Word >::size_type std_map_Sl_std_string_Sc_Pythia8_Word_Sg____len__(std::map< std::string,Pythia8::Word > const *self){
8498  return self->size();
8499  }
8500 SWIGINTERN std::map< std::string,Pythia8::Word >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_Word_Sg____getitem__(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::key_type const &key){
8501  std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::const_iterator i = self->find(key);
8502  if (i != self->end())
8503  return i->second;
8504  else
8505  throw std::out_of_range("key not found");
8506  }
8507 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Word_Sg____delitem__(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::key_type const &key){
8508  std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::iterator i = self->find(key);
8509  if (i != self->end())
8510  self->erase(i);
8511  else
8512  throw std::out_of_range("key not found");
8513  }
8514 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Word_Sg__has_key(std::map< std::string,Pythia8::Word > const *self,std::map< std::string,Pythia8::Word >::key_type const &key){
8515  std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::const_iterator i = self->find(key);
8516  return i != self->end();
8517  }
8518 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__keys(std::map< std::string,Pythia8::Word > *self){
8519  std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type size = self->size();
8520  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8521  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8522  if (pysize < 0) {
8523  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8524  SWIG_PYTHON_THREAD_END_BLOCK;
8525  return NULL;
8526  }
8527  PyObject* keyList = PyList_New(pysize);
8528  std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::const_iterator i = self->begin();
8529  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8530  PyList_SET_ITEM(keyList, j, swig::from(i->first));
8531  }
8532  SWIG_PYTHON_THREAD_END_BLOCK;
8533  return keyList;
8534  }
8535 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__values(std::map< std::string,Pythia8::Word > *self){
8536  std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type size = self->size();
8537  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8538  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8539  if (pysize < 0) {
8540  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8541  SWIG_PYTHON_THREAD_END_BLOCK;
8542  return NULL;
8543  }
8544  PyObject* valList = PyList_New(pysize);
8545  std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::const_iterator i = self->begin();
8546  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8547  PyList_SET_ITEM(valList, j, swig::from(i->second));
8548  }
8549  SWIG_PYTHON_THREAD_END_BLOCK;
8550  return valList;
8551  }
8552 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__items(std::map< std::string,Pythia8::Word > *self){
8553  std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type size = self->size();
8554  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8555  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8556  if (pysize < 0) {
8557  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8558  SWIG_PYTHON_THREAD_END_BLOCK;
8559  return NULL;
8560  }
8561  PyObject* itemList = PyList_New(pysize);
8562  std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::const_iterator i = self->begin();
8563  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8564  PyList_SET_ITEM(itemList, j, swig::from(*i));
8565  }
8566  SWIG_PYTHON_THREAD_END_BLOCK;
8567  return itemList;
8568  }
8569 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Word_Sg____contains__(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::key_type const &key){
8570  return self->find(key) != self->end();
8571  }
8572 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__key_iterator(std::map< std::string,Pythia8::Word > *self,PyObject **PYTHON_SELF){
8573  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8574  }
8575 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__value_iterator(std::map< std::string,Pythia8::Word > *self,PyObject **PYTHON_SELF){
8576  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8577  }
8578 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Word_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::key_type const &key){
8579  self->erase(key);
8580  }
8581 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Word_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::key_type const &key,std::map< std::string,Pythia8::Word >::mapped_type const &x){
8582  (*self)[key] = x;
8583  }
8584 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__asdict(std::map< std::string,Pythia8::Word > *self){
8585  return swig::traits_from< std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > > >::asdict(*self);
8586  }
8587 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Word_Sg__erase__SWIG_1(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::iterator position){ self->erase(position); }
8588 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Word_Sg__erase__SWIG_2(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::iterator first,std::map< std::string,Pythia8::Word >::iterator last){ self->erase(first, last); }
8589 
8590  namespace swig {
8591  template <> struct traits< Pythia8::FVec > {
8592  typedef pointer_category category;
8593  static const char* type_name() { return"Pythia8::FVec"; }
8594  };
8595  }
8596 
8597 
8598  namespace swig {
8599  template <> struct traits<std::pair< std::string, Pythia8::FVec > > {
8600  typedef pointer_category category;
8601  static const char* type_name() {
8602  return "std::pair<" "std::string" "," "Pythia8::FVec" " >";
8603  }
8604  };
8605  }
8606 
8607 
8608  namespace swig {
8609  template <> struct traits<std::map< std::string, Pythia8::FVec, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::FVec > > > > {
8610  typedef pointer_category category;
8611  static const char* type_name() {
8612  return "std::map<" "std::string" "," "Pythia8::FVec" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::FVec > >" " >";
8613  }
8614  };
8615  }
8616 
8617 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__iterator(std::map< std::string,Pythia8::FVec > *self,PyObject **PYTHON_SELF){
8618  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8619  }
8620 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____nonzero__(std::map< std::string,Pythia8::FVec > const *self){
8621  return !(self->empty());
8622  }
8623 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____bool__(std::map< std::string,Pythia8::FVec > const *self){
8624  return !(self->empty());
8625  }
8626 SWIGINTERN std::map< std::string,Pythia8::FVec >::size_type std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____len__(std::map< std::string,Pythia8::FVec > const *self){
8627  return self->size();
8628  }
8629 SWIGINTERN std::map< std::string,Pythia8::FVec >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____getitem__(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::key_type const &key){
8630  std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::const_iterator i = self->find(key);
8631  if (i != self->end())
8632  return i->second;
8633  else
8634  throw std::out_of_range("key not found");
8635  }
8636 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____delitem__(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::key_type const &key){
8637  std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::iterator i = self->find(key);
8638  if (i != self->end())
8639  self->erase(i);
8640  else
8641  throw std::out_of_range("key not found");
8642  }
8643 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__has_key(std::map< std::string,Pythia8::FVec > const *self,std::map< std::string,Pythia8::FVec >::key_type const &key){
8644  std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::const_iterator i = self->find(key);
8645  return i != self->end();
8646  }
8647 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__keys(std::map< std::string,Pythia8::FVec > *self){
8648  std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type size = self->size();
8649  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8650  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8651  if (pysize < 0) {
8652  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8653  SWIG_PYTHON_THREAD_END_BLOCK;
8654  return NULL;
8655  }
8656  PyObject* keyList = PyList_New(pysize);
8657  std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::const_iterator i = self->begin();
8658  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8659  PyList_SET_ITEM(keyList, j, swig::from(i->first));
8660  }
8661  SWIG_PYTHON_THREAD_END_BLOCK;
8662  return keyList;
8663  }
8664 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__values(std::map< std::string,Pythia8::FVec > *self){
8665  std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type size = self->size();
8666  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8667  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8668  if (pysize < 0) {
8669  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8670  SWIG_PYTHON_THREAD_END_BLOCK;
8671  return NULL;
8672  }
8673  PyObject* valList = PyList_New(pysize);
8674  std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::const_iterator i = self->begin();
8675  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8676  PyList_SET_ITEM(valList, j, swig::from(i->second));
8677  }
8678  SWIG_PYTHON_THREAD_END_BLOCK;
8679  return valList;
8680  }
8681 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__items(std::map< std::string,Pythia8::FVec > *self){
8682  std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type size = self->size();
8683  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8684  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8685  if (pysize < 0) {
8686  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8687  SWIG_PYTHON_THREAD_END_BLOCK;
8688  return NULL;
8689  }
8690  PyObject* itemList = PyList_New(pysize);
8691  std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::const_iterator i = self->begin();
8692  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8693  PyList_SET_ITEM(itemList, j, swig::from(*i));
8694  }
8695  SWIG_PYTHON_THREAD_END_BLOCK;
8696  return itemList;
8697  }
8698 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____contains__(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::key_type const &key){
8699  return self->find(key) != self->end();
8700  }
8701 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__key_iterator(std::map< std::string,Pythia8::FVec > *self,PyObject **PYTHON_SELF){
8702  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8703  }
8704 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__value_iterator(std::map< std::string,Pythia8::FVec > *self,PyObject **PYTHON_SELF){
8705  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8706  }
8707 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::key_type const &key){
8708  self->erase(key);
8709  }
8710 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::key_type const &key,std::map< std::string,Pythia8::FVec >::mapped_type const &x){
8711  (*self)[key] = x;
8712  }
8713 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__asdict(std::map< std::string,Pythia8::FVec > *self){
8714  return swig::traits_from< std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > > >::asdict(*self);
8715  }
8716 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__erase__SWIG_1(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::iterator position){ self->erase(position); }
8717 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__erase__SWIG_2(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::iterator first,std::map< std::string,Pythia8::FVec >::iterator last){ self->erase(first, last); }
8718 
8719  namespace swig {
8720  template <> struct traits< Pythia8::MVec > {
8721  typedef pointer_category category;
8722  static const char* type_name() { return"Pythia8::MVec"; }
8723  };
8724  }
8725 
8726 
8727  namespace swig {
8728  template <> struct traits<std::pair< std::string, Pythia8::MVec > > {
8729  typedef pointer_category category;
8730  static const char* type_name() {
8731  return "std::pair<" "std::string" "," "Pythia8::MVec" " >";
8732  }
8733  };
8734  }
8735 
8736 
8737  namespace swig {
8738  template <> struct traits<std::map< std::string, Pythia8::MVec, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::MVec > > > > {
8739  typedef pointer_category category;
8740  static const char* type_name() {
8741  return "std::map<" "std::string" "," "Pythia8::MVec" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::MVec > >" " >";
8742  }
8743  };
8744  }
8745 
8746 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__iterator(std::map< std::string,Pythia8::MVec > *self,PyObject **PYTHON_SELF){
8747  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8748  }
8749 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____nonzero__(std::map< std::string,Pythia8::MVec > const *self){
8750  return !(self->empty());
8751  }
8752 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____bool__(std::map< std::string,Pythia8::MVec > const *self){
8753  return !(self->empty());
8754  }
8755 SWIGINTERN std::map< std::string,Pythia8::MVec >::size_type std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____len__(std::map< std::string,Pythia8::MVec > const *self){
8756  return self->size();
8757  }
8758 SWIGINTERN std::map< std::string,Pythia8::MVec >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____getitem__(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::key_type const &key){
8759  std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::const_iterator i = self->find(key);
8760  if (i != self->end())
8761  return i->second;
8762  else
8763  throw std::out_of_range("key not found");
8764  }
8765 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____delitem__(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::key_type const &key){
8766  std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::iterator i = self->find(key);
8767  if (i != self->end())
8768  self->erase(i);
8769  else
8770  throw std::out_of_range("key not found");
8771  }
8772 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__has_key(std::map< std::string,Pythia8::MVec > const *self,std::map< std::string,Pythia8::MVec >::key_type const &key){
8773  std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::const_iterator i = self->find(key);
8774  return i != self->end();
8775  }
8776 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__keys(std::map< std::string,Pythia8::MVec > *self){
8777  std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type size = self->size();
8778  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8779  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8780  if (pysize < 0) {
8781  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8782  SWIG_PYTHON_THREAD_END_BLOCK;
8783  return NULL;
8784  }
8785  PyObject* keyList = PyList_New(pysize);
8786  std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::const_iterator i = self->begin();
8787  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8788  PyList_SET_ITEM(keyList, j, swig::from(i->first));
8789  }
8790  SWIG_PYTHON_THREAD_END_BLOCK;
8791  return keyList;
8792  }
8793 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__values(std::map< std::string,Pythia8::MVec > *self){
8794  std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type size = self->size();
8795  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8796  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8797  if (pysize < 0) {
8798  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8799  SWIG_PYTHON_THREAD_END_BLOCK;
8800  return NULL;
8801  }
8802  PyObject* valList = PyList_New(pysize);
8803  std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::const_iterator i = self->begin();
8804  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8805  PyList_SET_ITEM(valList, j, swig::from(i->second));
8806  }
8807  SWIG_PYTHON_THREAD_END_BLOCK;
8808  return valList;
8809  }
8810 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__items(std::map< std::string,Pythia8::MVec > *self){
8811  std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type size = self->size();
8812  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8813  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8814  if (pysize < 0) {
8815  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8816  SWIG_PYTHON_THREAD_END_BLOCK;
8817  return NULL;
8818  }
8819  PyObject* itemList = PyList_New(pysize);
8820  std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::const_iterator i = self->begin();
8821  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8822  PyList_SET_ITEM(itemList, j, swig::from(*i));
8823  }
8824  SWIG_PYTHON_THREAD_END_BLOCK;
8825  return itemList;
8826  }
8827 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____contains__(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::key_type const &key){
8828  return self->find(key) != self->end();
8829  }
8830 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__key_iterator(std::map< std::string,Pythia8::MVec > *self,PyObject **PYTHON_SELF){
8831  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8832  }
8833 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__value_iterator(std::map< std::string,Pythia8::MVec > *self,PyObject **PYTHON_SELF){
8834  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8835  }
8836 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::key_type const &key){
8837  self->erase(key);
8838  }
8839 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::key_type const &key,std::map< std::string,Pythia8::MVec >::mapped_type const &x){
8840  (*self)[key] = x;
8841  }
8842 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__asdict(std::map< std::string,Pythia8::MVec > *self){
8843  return swig::traits_from< std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > > >::asdict(*self);
8844  }
8845 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__erase__SWIG_1(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::iterator position){ self->erase(position); }
8846 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__erase__SWIG_2(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::iterator first,std::map< std::string,Pythia8::MVec >::iterator last){ self->erase(first, last); }
8847 
8848  namespace swig {
8849  template <> struct traits< Pythia8::PVec > {
8850  typedef pointer_category category;
8851  static const char* type_name() { return"Pythia8::PVec"; }
8852  };
8853  }
8854 
8855 
8856  namespace swig {
8857  template <> struct traits<std::pair< std::string, Pythia8::PVec > > {
8858  typedef pointer_category category;
8859  static const char* type_name() {
8860  return "std::pair<" "std::string" "," "Pythia8::PVec" " >";
8861  }
8862  };
8863  }
8864 
8865 
8866  namespace swig {
8867  template <> struct traits<std::map< std::string, Pythia8::PVec, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::PVec > > > > {
8868  typedef pointer_category category;
8869  static const char* type_name() {
8870  return "std::map<" "std::string" "," "Pythia8::PVec" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::PVec > >" " >";
8871  }
8872  };
8873  }
8874 
8875 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__iterator(std::map< std::string,Pythia8::PVec > *self,PyObject **PYTHON_SELF){
8876  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8877  }
8878 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____nonzero__(std::map< std::string,Pythia8::PVec > const *self){
8879  return !(self->empty());
8880  }
8881 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____bool__(std::map< std::string,Pythia8::PVec > const *self){
8882  return !(self->empty());
8883  }
8884 SWIGINTERN std::map< std::string,Pythia8::PVec >::size_type std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____len__(std::map< std::string,Pythia8::PVec > const *self){
8885  return self->size();
8886  }
8887 SWIGINTERN std::map< std::string,Pythia8::PVec >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____getitem__(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::key_type const &key){
8888  std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::const_iterator i = self->find(key);
8889  if (i != self->end())
8890  return i->second;
8891  else
8892  throw std::out_of_range("key not found");
8893  }
8894 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____delitem__(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::key_type const &key){
8895  std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::iterator i = self->find(key);
8896  if (i != self->end())
8897  self->erase(i);
8898  else
8899  throw std::out_of_range("key not found");
8900  }
8901 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__has_key(std::map< std::string,Pythia8::PVec > const *self,std::map< std::string,Pythia8::PVec >::key_type const &key){
8902  std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::const_iterator i = self->find(key);
8903  return i != self->end();
8904  }
8905 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__keys(std::map< std::string,Pythia8::PVec > *self){
8906  std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type size = self->size();
8907  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8908  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8909  if (pysize < 0) {
8910  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8911  SWIG_PYTHON_THREAD_END_BLOCK;
8912  return NULL;
8913  }
8914  PyObject* keyList = PyList_New(pysize);
8915  std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::const_iterator i = self->begin();
8916  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8917  PyList_SET_ITEM(keyList, j, swig::from(i->first));
8918  }
8919  SWIG_PYTHON_THREAD_END_BLOCK;
8920  return keyList;
8921  }
8922 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__values(std::map< std::string,Pythia8::PVec > *self){
8923  std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type size = self->size();
8924  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8925  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8926  if (pysize < 0) {
8927  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8928  SWIG_PYTHON_THREAD_END_BLOCK;
8929  return NULL;
8930  }
8931  PyObject* valList = PyList_New(pysize);
8932  std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::const_iterator i = self->begin();
8933  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8934  PyList_SET_ITEM(valList, j, swig::from(i->second));
8935  }
8936  SWIG_PYTHON_THREAD_END_BLOCK;
8937  return valList;
8938  }
8939 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__items(std::map< std::string,Pythia8::PVec > *self){
8940  std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type size = self->size();
8941  Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
8942  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
8943  if (pysize < 0) {
8944  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
8945  SWIG_PYTHON_THREAD_END_BLOCK;
8946  return NULL;
8947  }
8948  PyObject* itemList = PyList_New(pysize);
8949  std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::const_iterator i = self->begin();
8950  for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
8951  PyList_SET_ITEM(itemList, j, swig::from(*i));
8952  }
8953  SWIG_PYTHON_THREAD_END_BLOCK;
8954  return itemList;
8955  }
8956 SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____contains__(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::key_type const &key){
8957  return self->find(key) != self->end();
8958  }
8959 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__key_iterator(std::map< std::string,Pythia8::PVec > *self,PyObject **PYTHON_SELF){
8960  return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8961  }
8962 SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__value_iterator(std::map< std::string,Pythia8::PVec > *self,PyObject **PYTHON_SELF){
8963  return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8964  }
8965 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::key_type const &key){
8966  self->erase(key);
8967  }
8968 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::key_type const &key,std::map< std::string,Pythia8::PVec >::mapped_type const &x){
8969  (*self)[key] = x;
8970  }
8971 SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__asdict(std::map< std::string,Pythia8::PVec > *self){
8972  return swig::traits_from< std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > > >::asdict(*self);
8973  }
8974 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__erase__SWIG_1(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::iterator position){ self->erase(position); }
8975 SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__erase__SWIG_2(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::iterator first,std::map< std::string,Pythia8::PVec >::iterator last){ self->erase(first, last); }
8976 
8977  namespace swig {
8978  template <> struct traits< Pythia8::Clustering > {
8979  typedef pointer_category category;
8980  static const char* type_name() { return"Pythia8::Clustering"; }
8981  };
8982  }
8983 
8984 
8985  namespace swig {
8986  template <> struct traits<std::vector< Pythia8::Clustering, std::allocator< Pythia8::Clustering > > > {
8987  typedef pointer_category category;
8988  static const char* type_name() {
8989  return "std::vector<" "Pythia8::Clustering" "," "std::allocator< Pythia8::Clustering >" " >";
8990  }
8991  };
8992  }
8993 
8994 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_Clustering_Sg__iterator(std::vector< Pythia8::Clustering > *self,PyObject **PYTHON_SELF){
8995  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
8996  }
8997 SWIGINTERN bool std_vector_Sl_Pythia8_Clustering_Sg____nonzero__(std::vector< Pythia8::Clustering > const *self){
8998  return !(self->empty());
8999  }
9000 SWIGINTERN bool std_vector_Sl_Pythia8_Clustering_Sg____bool__(std::vector< Pythia8::Clustering > const *self){
9001  return !(self->empty());
9002  }
9003 SWIGINTERN std::vector< Pythia8::Clustering >::size_type std_vector_Sl_Pythia8_Clustering_Sg____len__(std::vector< Pythia8::Clustering > const *self){
9004  return self->size();
9005  }
9006 SWIGINTERN std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *std_vector_Sl_Pythia8_Clustering_Sg____getslice__(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i,std::vector< Pythia8::Clustering >::difference_type j){
9007  return swig::getslice(self, i, j, 1);
9008  }
9009 SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____setslice____SWIG_0(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i,std::vector< Pythia8::Clustering >::difference_type j){
9010  swig::setslice(self, i, j, 1, std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >());
9011  }
9012 SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____setslice____SWIG_1(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i,std::vector< Pythia8::Clustering >::difference_type j,std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &v){
9013  swig::setslice(self, i, j, 1, v);
9014  }
9015 SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____delslice__(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i,std::vector< Pythia8::Clustering >::difference_type j){
9016  swig::delslice(self, i, j, 1);
9017  }
9018 SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____delitem____SWIG_0(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i){
9019  swig::erase(self, swig::getpos(self, i));
9020  }
9021 SWIGINTERN std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *std_vector_Sl_Pythia8_Clustering_Sg____getitem____SWIG_0(std::vector< Pythia8::Clustering > *self,PySliceObject *slice){
9022  Py_ssize_t i, j, step;
9023  if( !PySlice_Check(slice) ) {
9024  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9025  return NULL;
9026  }
9027  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9028  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type id = i;
9029  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type jd = j;
9030  return swig::getslice(self, id, jd, step);
9031  }
9032 SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____setitem____SWIG_0(std::vector< Pythia8::Clustering > *self,PySliceObject *slice,std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &v){
9033  Py_ssize_t i, j, step;
9034  if( !PySlice_Check(slice) ) {
9035  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9036  return;
9037  }
9038  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9039  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type id = i;
9040  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type jd = j;
9041  swig::setslice(self, id, jd, step, v);
9042  }
9043 SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____setitem____SWIG_1(std::vector< Pythia8::Clustering > *self,PySliceObject *slice){
9044  Py_ssize_t i, j, step;
9045  if( !PySlice_Check(slice) ) {
9046  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9047  return;
9048  }
9049  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9050  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type id = i;
9051  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type jd = j;
9052  swig::delslice(self, id, jd, step);
9053  }
9054 SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____delitem____SWIG_1(std::vector< Pythia8::Clustering > *self,PySliceObject *slice){
9055  Py_ssize_t i, j, step;
9056  if( !PySlice_Check(slice) ) {
9057  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9058  return;
9059  }
9060  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9061  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type id = i;
9062  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type jd = j;
9063  swig::delslice(self, id, jd, step);
9064  }
9065 SWIGINTERN std::vector< Pythia8::Clustering >::value_type const &std_vector_Sl_Pythia8_Clustering_Sg____getitem____SWIG_1(std::vector< Pythia8::Clustering > const *self,std::vector< Pythia8::Clustering >::difference_type i){
9066  return *(swig::cgetpos(self, i));
9067  }
9068 SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____setitem____SWIG_2(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i,std::vector< Pythia8::Clustering >::value_type const &x){
9069  *(swig::getpos(self,i)) = x;
9070  }
9071 SWIGINTERN std::vector< Pythia8::Clustering >::value_type std_vector_Sl_Pythia8_Clustering_Sg__pop(std::vector< Pythia8::Clustering > *self){
9072  if (self->size() == 0)
9073  throw std::out_of_range("pop from empty container");
9074  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::value_type x = self->back();
9075  self->pop_back();
9076  return x;
9077  }
9078 SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg__append(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::value_type const &x){
9079  self->push_back(x);
9080  }
9081 SWIGINTERN std::vector< Pythia8::Clustering >::iterator std_vector_Sl_Pythia8_Clustering_Sg__erase__SWIG_0(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::iterator pos){ return self->erase(pos); }
9082 SWIGINTERN std::vector< Pythia8::Clustering >::iterator std_vector_Sl_Pythia8_Clustering_Sg__erase__SWIG_1(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::iterator first,std::vector< Pythia8::Clustering >::iterator last){ return self->erase(first, last); }
9083 SWIGINTERN std::vector< Pythia8::Clustering >::iterator std_vector_Sl_Pythia8_Clustering_Sg__insert__SWIG_0(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::iterator pos,std::vector< Pythia8::Clustering >::value_type const &x){ return self->insert(pos, x); }
9084 SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg__insert__SWIG_1(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::iterator pos,std::vector< Pythia8::Clustering >::size_type n,std::vector< Pythia8::Clustering >::value_type const &x){ self->insert(pos, n, x); }
9085 
9086  namespace swig {
9087  template <> struct traits< Pythia8::HelicityParticle > {
9088  typedef pointer_category category;
9089  static const char* type_name() { return"Pythia8::HelicityParticle"; }
9090  };
9091  }
9092 
9093 
9094  namespace swig {
9095  template <> struct traits<std::vector< Pythia8::HelicityParticle, std::allocator< Pythia8::HelicityParticle > > > {
9096  typedef pointer_category category;
9097  static const char* type_name() {
9098  return "std::vector<" "Pythia8::HelicityParticle" "," "std::allocator< Pythia8::HelicityParticle >" " >";
9099  }
9100  };
9101  }
9102 
9103 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_HelicityParticle_Sg__iterator(std::vector< Pythia8::HelicityParticle > *self,PyObject **PYTHON_SELF){
9104  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
9105  }
9106 SWIGINTERN bool std_vector_Sl_Pythia8_HelicityParticle_Sg____nonzero__(std::vector< Pythia8::HelicityParticle > const *self){
9107  return !(self->empty());
9108  }
9109 SWIGINTERN bool std_vector_Sl_Pythia8_HelicityParticle_Sg____bool__(std::vector< Pythia8::HelicityParticle > const *self){
9110  return !(self->empty());
9111  }
9112 SWIGINTERN std::vector< Pythia8::HelicityParticle >::size_type std_vector_Sl_Pythia8_HelicityParticle_Sg____len__(std::vector< Pythia8::HelicityParticle > const *self){
9113  return self->size();
9114  }
9115 SWIGINTERN std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *std_vector_Sl_Pythia8_HelicityParticle_Sg____getslice__(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i,std::vector< Pythia8::HelicityParticle >::difference_type j){
9116  return swig::getslice(self, i, j, 1);
9117  }
9118 SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____setslice____SWIG_0(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i,std::vector< Pythia8::HelicityParticle >::difference_type j){
9119  swig::setslice(self, i, j, 1, std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >());
9120  }
9121 SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____setslice____SWIG_1(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i,std::vector< Pythia8::HelicityParticle >::difference_type j,std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &v){
9122  swig::setslice(self, i, j, 1, v);
9123  }
9124 SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____delslice__(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i,std::vector< Pythia8::HelicityParticle >::difference_type j){
9125  swig::delslice(self, i, j, 1);
9126  }
9127 SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____delitem____SWIG_0(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i){
9128  swig::erase(self, swig::getpos(self, i));
9129  }
9130 SWIGINTERN std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *std_vector_Sl_Pythia8_HelicityParticle_Sg____getitem____SWIG_0(std::vector< Pythia8::HelicityParticle > *self,PySliceObject *slice){
9131  Py_ssize_t i, j, step;
9132  if( !PySlice_Check(slice) ) {
9133  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9134  return NULL;
9135  }
9136  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9137  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type id = i;
9138  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type jd = j;
9139  return swig::getslice(self, id, jd, step);
9140  }
9141 SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____setitem____SWIG_0(std::vector< Pythia8::HelicityParticle > *self,PySliceObject *slice,std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &v){
9142  Py_ssize_t i, j, step;
9143  if( !PySlice_Check(slice) ) {
9144  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9145  return;
9146  }
9147  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9148  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type id = i;
9149  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type jd = j;
9150  swig::setslice(self, id, jd, step, v);
9151  }
9152 SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____setitem____SWIG_1(std::vector< Pythia8::HelicityParticle > *self,PySliceObject *slice){
9153  Py_ssize_t i, j, step;
9154  if( !PySlice_Check(slice) ) {
9155  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9156  return;
9157  }
9158  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9159  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type id = i;
9160  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type jd = j;
9161  swig::delslice(self, id, jd, step);
9162  }
9163 SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____delitem____SWIG_1(std::vector< Pythia8::HelicityParticle > *self,PySliceObject *slice){
9164  Py_ssize_t i, j, step;
9165  if( !PySlice_Check(slice) ) {
9166  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9167  return;
9168  }
9169  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9170  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type id = i;
9171  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type jd = j;
9172  swig::delslice(self, id, jd, step);
9173  }
9174 SWIGINTERN std::vector< Pythia8::HelicityParticle >::value_type const &std_vector_Sl_Pythia8_HelicityParticle_Sg____getitem____SWIG_1(std::vector< Pythia8::HelicityParticle > const *self,std::vector< Pythia8::HelicityParticle >::difference_type i){
9175  return *(swig::cgetpos(self, i));
9176  }
9177 SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____setitem____SWIG_2(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i,std::vector< Pythia8::HelicityParticle >::value_type const &x){
9178  *(swig::getpos(self,i)) = x;
9179  }
9180 SWIGINTERN std::vector< Pythia8::HelicityParticle >::value_type std_vector_Sl_Pythia8_HelicityParticle_Sg__pop(std::vector< Pythia8::HelicityParticle > *self){
9181  if (self->size() == 0)
9182  throw std::out_of_range("pop from empty container");
9183  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::value_type x = self->back();
9184  self->pop_back();
9185  return x;
9186  }
9187 SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg__append(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::value_type const &x){
9188  self->push_back(x);
9189  }
9190 SWIGINTERN std::vector< Pythia8::HelicityParticle >::iterator std_vector_Sl_Pythia8_HelicityParticle_Sg__erase__SWIG_0(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::iterator pos){ return self->erase(pos); }
9191 SWIGINTERN std::vector< Pythia8::HelicityParticle >::iterator std_vector_Sl_Pythia8_HelicityParticle_Sg__erase__SWIG_1(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::iterator first,std::vector< Pythia8::HelicityParticle >::iterator last){ return self->erase(first, last); }
9192 SWIGINTERN std::vector< Pythia8::HelicityParticle >::iterator std_vector_Sl_Pythia8_HelicityParticle_Sg__insert__SWIG_0(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::iterator pos,std::vector< Pythia8::HelicityParticle >::value_type const &x){ return self->insert(pos, x); }
9193 SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg__insert__SWIG_1(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::iterator pos,std::vector< Pythia8::HelicityParticle >::size_type n,std::vector< Pythia8::HelicityParticle >::value_type const &x){ self->insert(pos, n, x); }
9194 
9195  namespace swig {
9196  template <> struct traits< Pythia8::ProcessContainer > {
9197  typedef pointer_category category;
9198  static const char* type_name() { return"Pythia8::ProcessContainer"; }
9199  };
9200  }
9201 
9202 
9203  namespace swig {
9204  template <> struct traits<std::vector< Pythia8::ProcessContainer*, std::allocator< Pythia8::ProcessContainer * > > > {
9205  typedef value_category category;
9206  static const char* type_name() {
9207  return "std::vector<" "Pythia8::ProcessContainer" " *," "std::allocator< Pythia8::ProcessContainer * >" " >";
9208  }
9209  };
9210  }
9211 
9212 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__iterator(std::vector< Pythia8::ProcessContainer * > *self,PyObject **PYTHON_SELF){
9213  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
9214  }
9215 SWIGINTERN bool std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____nonzero__(std::vector< Pythia8::ProcessContainer * > const *self){
9216  return !(self->empty());
9217  }
9218 SWIGINTERN bool std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____bool__(std::vector< Pythia8::ProcessContainer * > const *self){
9219  return !(self->empty());
9220  }
9221 SWIGINTERN std::vector< Pythia8::ProcessContainer * >::size_type std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____len__(std::vector< Pythia8::ProcessContainer * > const *self){
9222  return self->size();
9223  }
9224 SWIGINTERN std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____getslice__(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i,std::vector< Pythia8::ProcessContainer * >::difference_type j){
9225  return swig::getslice(self, i, j, 1);
9226  }
9227 SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setslice____SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i,std::vector< Pythia8::ProcessContainer * >::difference_type j){
9228  swig::setslice(self, i, j, 1, std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >());
9229  }
9230 SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setslice____SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i,std::vector< Pythia8::ProcessContainer * >::difference_type j,std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &v){
9231  swig::setslice(self, i, j, 1, v);
9232  }
9233 SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____delslice__(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i,std::vector< Pythia8::ProcessContainer * >::difference_type j){
9234  swig::delslice(self, i, j, 1);
9235  }
9236 SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____delitem____SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i){
9237  swig::erase(self, swig::getpos(self, i));
9238  }
9239 SWIGINTERN std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____getitem____SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,PySliceObject *slice){
9240  Py_ssize_t i, j, step;
9241  if( !PySlice_Check(slice) ) {
9242  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9243  return NULL;
9244  }
9245  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9246  std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type id = i;
9247  std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type jd = j;
9248  return swig::getslice(self, id, jd, step);
9249  }
9250 SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setitem____SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,PySliceObject *slice,std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &v){
9251  Py_ssize_t i, j, step;
9252  if( !PySlice_Check(slice) ) {
9253  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9254  return;
9255  }
9256  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9257  std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type id = i;
9258  std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type jd = j;
9259  swig::setslice(self, id, jd, step, v);
9260  }
9261 SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setitem____SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,PySliceObject *slice){
9262  Py_ssize_t i, j, step;
9263  if( !PySlice_Check(slice) ) {
9264  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9265  return;
9266  }
9267  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9268  std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type id = i;
9269  std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type jd = j;
9270  swig::delslice(self, id, jd, step);
9271  }
9272 SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____delitem____SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,PySliceObject *slice){
9273  Py_ssize_t i, j, step;
9274  if( !PySlice_Check(slice) ) {
9275  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9276  return;
9277  }
9278  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9279  std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type id = i;
9280  std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type jd = j;
9281  swig::delslice(self, id, jd, step);
9282  }
9283 SWIGINTERN std::vector< Pythia8::ProcessContainer * >::value_type std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____getitem____SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i){
9284  return *(swig::cgetpos(self, i));
9285  }
9286 SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setitem____SWIG_2(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i,std::vector< Pythia8::ProcessContainer * >::value_type x){
9287  *(swig::getpos(self,i)) = x;
9288  }
9289 SWIGINTERN std::vector< Pythia8::ProcessContainer * >::value_type std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__pop(std::vector< Pythia8::ProcessContainer * > *self){
9290  if (self->size() == 0)
9291  throw std::out_of_range("pop from empty container");
9292  std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::value_type x = self->back();
9293  self->pop_back();
9294  return x;
9295  }
9296 SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__append(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::value_type x){
9297  self->push_back(x);
9298  }
9299 SWIGINTERN std::vector< Pythia8::ProcessContainer * >::iterator std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__erase__SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::iterator pos){ return self->erase(pos); }
9300 SWIGINTERN std::vector< Pythia8::ProcessContainer * >::iterator std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__erase__SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::iterator first,std::vector< Pythia8::ProcessContainer * >::iterator last){ return self->erase(first, last); }
9301 SWIGINTERN std::vector< Pythia8::ProcessContainer * >::iterator std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__insert__SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::iterator pos,std::vector< Pythia8::ProcessContainer * >::value_type x){ return self->insert(pos, x); }
9302 SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__insert__SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::iterator pos,std::vector< Pythia8::ProcessContainer * >::size_type n,std::vector< Pythia8::ProcessContainer * >::value_type x){ self->insert(pos, n, x); }
9303 
9304  namespace swig {
9305  template <> struct traits< Pythia8::ResonanceWidths > {
9306  typedef pointer_category category;
9307  static const char* type_name() { return"Pythia8::ResonanceWidths"; }
9308  };
9309  }
9310 
9311 
9312  namespace swig {
9313  template <> struct traits<std::vector< Pythia8::ResonanceWidths*, std::allocator< Pythia8::ResonanceWidths * > > > {
9314  typedef value_category category;
9315  static const char* type_name() {
9316  return "std::vector<" "Pythia8::ResonanceWidths" " *," "std::allocator< Pythia8::ResonanceWidths * >" " >";
9317  }
9318  };
9319  }
9320 
9321 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__iterator(std::vector< Pythia8::ResonanceWidths * > *self,PyObject **PYTHON_SELF){
9322  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
9323  }
9324 SWIGINTERN bool std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____nonzero__(std::vector< Pythia8::ResonanceWidths * > const *self){
9325  return !(self->empty());
9326  }
9327 SWIGINTERN bool std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____bool__(std::vector< Pythia8::ResonanceWidths * > const *self){
9328  return !(self->empty());
9329  }
9330 SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::size_type std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____len__(std::vector< Pythia8::ResonanceWidths * > const *self){
9331  return self->size();
9332  }
9333 SWIGINTERN std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____getslice__(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i,std::vector< Pythia8::ResonanceWidths * >::difference_type j){
9334  return swig::getslice(self, i, j, 1);
9335  }
9336 SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setslice____SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i,std::vector< Pythia8::ResonanceWidths * >::difference_type j){
9337  swig::setslice(self, i, j, 1, std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >());
9338  }
9339 SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setslice____SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i,std::vector< Pythia8::ResonanceWidths * >::difference_type j,std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &v){
9340  swig::setslice(self, i, j, 1, v);
9341  }
9342 SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____delslice__(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i,std::vector< Pythia8::ResonanceWidths * >::difference_type j){
9343  swig::delslice(self, i, j, 1);
9344  }
9345 SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____delitem____SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i){
9346  swig::erase(self, swig::getpos(self, i));
9347  }
9348 SWIGINTERN std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____getitem____SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,PySliceObject *slice){
9349  Py_ssize_t i, j, step;
9350  if( !PySlice_Check(slice) ) {
9351  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9352  return NULL;
9353  }
9354  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9355  std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type id = i;
9356  std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type jd = j;
9357  return swig::getslice(self, id, jd, step);
9358  }
9359 SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setitem____SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,PySliceObject *slice,std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &v){
9360  Py_ssize_t i, j, step;
9361  if( !PySlice_Check(slice) ) {
9362  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9363  return;
9364  }
9365  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9366  std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type id = i;
9367  std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type jd = j;
9368  swig::setslice(self, id, jd, step, v);
9369  }
9370 SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setitem____SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,PySliceObject *slice){
9371  Py_ssize_t i, j, step;
9372  if( !PySlice_Check(slice) ) {
9373  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9374  return;
9375  }
9376  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9377  std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type id = i;
9378  std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type jd = j;
9379  swig::delslice(self, id, jd, step);
9380  }
9381 SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____delitem____SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,PySliceObject *slice){
9382  Py_ssize_t i, j, step;
9383  if( !PySlice_Check(slice) ) {
9384  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9385  return;
9386  }
9387  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9388  std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type id = i;
9389  std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type jd = j;
9390  swig::delslice(self, id, jd, step);
9391  }
9392 SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::value_type std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____getitem____SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i){
9393  return *(swig::cgetpos(self, i));
9394  }
9395 SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setitem____SWIG_2(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i,std::vector< Pythia8::ResonanceWidths * >::value_type x){
9396  *(swig::getpos(self,i)) = x;
9397  }
9398 SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::value_type std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__pop(std::vector< Pythia8::ResonanceWidths * > *self){
9399  if (self->size() == 0)
9400  throw std::out_of_range("pop from empty container");
9401  std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::value_type x = self->back();
9402  self->pop_back();
9403  return x;
9404  }
9405 SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__append(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::value_type x){
9406  self->push_back(x);
9407  }
9408 SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::iterator std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__erase__SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::iterator pos){ return self->erase(pos); }
9409 SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::iterator std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__erase__SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::iterator first,std::vector< Pythia8::ResonanceWidths * >::iterator last){ return self->erase(first, last); }
9410 SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::iterator std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__insert__SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::iterator pos,std::vector< Pythia8::ResonanceWidths * >::value_type x){ return self->insert(pos, x); }
9411 SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__insert__SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::iterator pos,std::vector< Pythia8::ResonanceWidths * >::size_type n,std::vector< Pythia8::ResonanceWidths * >::value_type x){ self->insert(pos, n, x); }
9412 
9413  namespace swig {
9414  template <> struct traits< Pythia8::SigmaProcess > {
9415  typedef pointer_category category;
9416  static const char* type_name() { return"Pythia8::SigmaProcess"; }
9417  };
9418  }
9419 
9420 
9421  namespace swig {
9422  template <> struct traits<std::vector< Pythia8::SigmaProcess*, std::allocator< Pythia8::SigmaProcess * > > > {
9423  typedef value_category category;
9424  static const char* type_name() {
9425  return "std::vector<" "Pythia8::SigmaProcess" " *," "std::allocator< Pythia8::SigmaProcess * >" " >";
9426  }
9427  };
9428  }
9429 
9430 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__iterator(std::vector< Pythia8::SigmaProcess * > *self,PyObject **PYTHON_SELF){
9431  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
9432  }
9433 SWIGINTERN bool std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____nonzero__(std::vector< Pythia8::SigmaProcess * > const *self){
9434  return !(self->empty());
9435  }
9436 SWIGINTERN bool std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____bool__(std::vector< Pythia8::SigmaProcess * > const *self){
9437  return !(self->empty());
9438  }
9439 SWIGINTERN std::vector< Pythia8::SigmaProcess * >::size_type std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____len__(std::vector< Pythia8::SigmaProcess * > const *self){
9440  return self->size();
9441  }
9442 SWIGINTERN std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____getslice__(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i,std::vector< Pythia8::SigmaProcess * >::difference_type j){
9443  return swig::getslice(self, i, j, 1);
9444  }
9445 SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setslice____SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i,std::vector< Pythia8::SigmaProcess * >::difference_type j){
9446  swig::setslice(self, i, j, 1, std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >());
9447  }
9448 SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setslice____SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i,std::vector< Pythia8::SigmaProcess * >::difference_type j,std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &v){
9449  swig::setslice(self, i, j, 1, v);
9450  }
9451 SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____delslice__(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i,std::vector< Pythia8::SigmaProcess * >::difference_type j){
9452  swig::delslice(self, i, j, 1);
9453  }
9454 SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____delitem____SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i){
9455  swig::erase(self, swig::getpos(self, i));
9456  }
9457 SWIGINTERN std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____getitem____SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,PySliceObject *slice){
9458  Py_ssize_t i, j, step;
9459  if( !PySlice_Check(slice) ) {
9460  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9461  return NULL;
9462  }
9463  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9464  std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type id = i;
9465  std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type jd = j;
9466  return swig::getslice(self, id, jd, step);
9467  }
9468 SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setitem____SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,PySliceObject *slice,std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &v){
9469  Py_ssize_t i, j, step;
9470  if( !PySlice_Check(slice) ) {
9471  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9472  return;
9473  }
9474  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9475  std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type id = i;
9476  std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type jd = j;
9477  swig::setslice(self, id, jd, step, v);
9478  }
9479 SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setitem____SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,PySliceObject *slice){
9480  Py_ssize_t i, j, step;
9481  if( !PySlice_Check(slice) ) {
9482  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9483  return;
9484  }
9485  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9486  std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type id = i;
9487  std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type jd = j;
9488  swig::delslice(self, id, jd, step);
9489  }
9490 SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____delitem____SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,PySliceObject *slice){
9491  Py_ssize_t i, j, step;
9492  if( !PySlice_Check(slice) ) {
9493  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9494  return;
9495  }
9496  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9497  std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type id = i;
9498  std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type jd = j;
9499  swig::delslice(self, id, jd, step);
9500  }
9501 SWIGINTERN std::vector< Pythia8::SigmaProcess * >::value_type std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____getitem____SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i){
9502  return *(swig::cgetpos(self, i));
9503  }
9504 SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setitem____SWIG_2(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i,std::vector< Pythia8::SigmaProcess * >::value_type x){
9505  *(swig::getpos(self,i)) = x;
9506  }
9507 SWIGINTERN std::vector< Pythia8::SigmaProcess * >::value_type std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__pop(std::vector< Pythia8::SigmaProcess * > *self){
9508  if (self->size() == 0)
9509  throw std::out_of_range("pop from empty container");
9510  std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::value_type x = self->back();
9511  self->pop_back();
9512  return x;
9513  }
9514 SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__append(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::value_type x){
9515  self->push_back(x);
9516  }
9517 SWIGINTERN std::vector< Pythia8::SigmaProcess * >::iterator std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__erase__SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::iterator pos){ return self->erase(pos); }
9518 SWIGINTERN std::vector< Pythia8::SigmaProcess * >::iterator std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__erase__SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::iterator first,std::vector< Pythia8::SigmaProcess * >::iterator last){ return self->erase(first, last); }
9519 SWIGINTERN std::vector< Pythia8::SigmaProcess * >::iterator std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__insert__SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::iterator pos,std::vector< Pythia8::SigmaProcess * >::value_type x){ return self->insert(pos, x); }
9520 SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__insert__SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::iterator pos,std::vector< Pythia8::SigmaProcess * >::size_type n,std::vector< Pythia8::SigmaProcess * >::value_type x){ self->insert(pos, n, x); }
9521 
9522  namespace swig {
9523  template <> struct traits< Pythia8::Vec4 > {
9524  typedef pointer_category category;
9525  static const char* type_name() { return"Pythia8::Vec4"; }
9526  };
9527  }
9528 
9529 
9530  namespace swig {
9531  template <> struct traits<std::vector< Pythia8::Vec4, std::allocator< Pythia8::Vec4 > > > {
9532  typedef pointer_category category;
9533  static const char* type_name() {
9534  return "std::vector<" "Pythia8::Vec4" "," "std::allocator< Pythia8::Vec4 >" " >";
9535  }
9536  };
9537  }
9538 
9539 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_Vec4_Sg__iterator(std::vector< Pythia8::Vec4 > *self,PyObject **PYTHON_SELF){
9540  return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
9541  }
9542 SWIGINTERN bool std_vector_Sl_Pythia8_Vec4_Sg____nonzero__(std::vector< Pythia8::Vec4 > const *self){
9543  return !(self->empty());
9544  }
9545 SWIGINTERN bool std_vector_Sl_Pythia8_Vec4_Sg____bool__(std::vector< Pythia8::Vec4 > const *self){
9546  return !(self->empty());
9547  }
9548 SWIGINTERN std::vector< Pythia8::Vec4 >::size_type std_vector_Sl_Pythia8_Vec4_Sg____len__(std::vector< Pythia8::Vec4 > const *self){
9549  return self->size();
9550  }
9551 SWIGINTERN std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *std_vector_Sl_Pythia8_Vec4_Sg____getslice__(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i,std::vector< Pythia8::Vec4 >::difference_type j){
9552  return swig::getslice(self, i, j, 1);
9553  }
9554 SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____setslice____SWIG_0(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i,std::vector< Pythia8::Vec4 >::difference_type j){
9555  swig::setslice(self, i, j, 1, std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >());
9556  }
9557 SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____setslice____SWIG_1(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i,std::vector< Pythia8::Vec4 >::difference_type j,std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &v){
9558  swig::setslice(self, i, j, 1, v);
9559  }
9560 SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____delslice__(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i,std::vector< Pythia8::Vec4 >::difference_type j){
9561  swig::delslice(self, i, j, 1);
9562  }
9563 SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____delitem____SWIG_0(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i){
9564  swig::erase(self, swig::getpos(self, i));
9565  }
9566 SWIGINTERN std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *std_vector_Sl_Pythia8_Vec4_Sg____getitem____SWIG_0(std::vector< Pythia8::Vec4 > *self,PySliceObject *slice){
9567  Py_ssize_t i, j, step;
9568  if( !PySlice_Check(slice) ) {
9569  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9570  return NULL;
9571  }
9572  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9573  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type id = i;
9574  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type jd = j;
9575  return swig::getslice(self, id, jd, step);
9576  }
9577 SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____setitem____SWIG_0(std::vector< Pythia8::Vec4 > *self,PySliceObject *slice,std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &v){
9578  Py_ssize_t i, j, step;
9579  if( !PySlice_Check(slice) ) {
9580  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9581  return;
9582  }
9583  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9584  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type id = i;
9585  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type jd = j;
9586  swig::setslice(self, id, jd, step, v);
9587  }
9588 SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____setitem____SWIG_1(std::vector< Pythia8::Vec4 > *self,PySliceObject *slice){
9589  Py_ssize_t i, j, step;
9590  if( !PySlice_Check(slice) ) {
9591  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9592  return;
9593  }
9594  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9595  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type id = i;
9596  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type jd = j;
9597  swig::delslice(self, id, jd, step);
9598  }
9599 SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____delitem____SWIG_1(std::vector< Pythia8::Vec4 > *self,PySliceObject *slice){
9600  Py_ssize_t i, j, step;
9601  if( !PySlice_Check(slice) ) {
9602  SWIG_Error(SWIG_TypeError, "Slice object expected.");
9603  return;
9604  }
9605  PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
9606  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type id = i;
9607  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type jd = j;
9608  swig::delslice(self, id, jd, step);
9609  }
9610 SWIGINTERN std::vector< Pythia8::Vec4 >::value_type const &std_vector_Sl_Pythia8_Vec4_Sg____getitem____SWIG_1(std::vector< Pythia8::Vec4 > const *self,std::vector< Pythia8::Vec4 >::difference_type i){
9611  return *(swig::cgetpos(self, i));
9612  }
9613 SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____setitem____SWIG_2(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i,std::vector< Pythia8::Vec4 >::value_type const &x){
9614  *(swig::getpos(self,i)) = x;
9615  }
9616 SWIGINTERN std::vector< Pythia8::Vec4 >::value_type std_vector_Sl_Pythia8_Vec4_Sg__pop(std::vector< Pythia8::Vec4 > *self){
9617  if (self->size() == 0)
9618  throw std::out_of_range("pop from empty container");
9619  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::value_type x = self->back();
9620  self->pop_back();
9621  return x;
9622  }
9623 SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg__append(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::value_type const &x){
9624  self->push_back(x);
9625  }
9626 SWIGINTERN std::vector< Pythia8::Vec4 >::iterator std_vector_Sl_Pythia8_Vec4_Sg__erase__SWIG_0(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::iterator pos){ return self->erase(pos); }
9627 SWIGINTERN std::vector< Pythia8::Vec4 >::iterator std_vector_Sl_Pythia8_Vec4_Sg__erase__SWIG_1(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::iterator first,std::vector< Pythia8::Vec4 >::iterator last){ return self->erase(first, last); }
9628 SWIGINTERN std::vector< Pythia8::Vec4 >::iterator std_vector_Sl_Pythia8_Vec4_Sg__insert__SWIG_0(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::iterator pos,std::vector< Pythia8::Vec4 >::value_type const &x){ return self->insert(pos, x); }
9629 SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg__insert__SWIG_1(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::iterator pos,std::vector< Pythia8::Vec4 >::size_type n,std::vector< Pythia8::Vec4 >::value_type const &x){ self->insert(pos, n, x); }
9630 
9631 
9632 /* ---------------------------------------------------
9633  * C++ director class methods
9634  * --------------------------------------------------- */
9635 
9636 /* ----------------------------------------------------------------------------
9637  * This file was automatically generated by SWIG (http://www.swig.org).
9638  * Version 3.0.8
9639  *
9640  * This file is not intended to be easily readable and contains a number of
9641  * coding conventions designed to improve portability and efficiency. Do not make
9642  * changes to this file unless you know what you are doing--modify the SWIG
9643  * interface file instead.
9644  * ----------------------------------------------------------------------------- */
9645 
9646 #ifndef SWIG_pythia8_WRAP_H_
9647 #define SWIG_pythia8_WRAP_H_
9648 
9649 #include <map>
9650 #include <string>
9651 
9652 
9654 
9655 public:
9656  SwigDirector_RndmEngine(PyObject *self);
9657  virtual ~SwigDirector_RndmEngine();
9658  virtual double flat();
9659 
9660 /* Internal director utilities */
9661 public:
9662  bool swig_get_inner(const char *swig_protected_method_name) const {
9663  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
9664  return (iv != swig_inner.end() ? iv->second : false);
9665  }
9666  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
9667  swig_inner[swig_protected_method_name] = swig_val;
9668  }
9669 private:
9670  mutable std::map<std::string, bool> swig_inner;
9671 
9672 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
9673 /* VTable implementation */
9674  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
9675  PyObject *method = vtable[method_index];
9676  if (!method) {
9677  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
9678  method = PyObject_GetAttr(swig_get_self(), name);
9679  if (!method) {
9680  std::string msg = "Method in class RndmEngine doesn't exist, undefined ";
9681  msg += method_name;
9682  Swig::DirectorMethodException::raise(msg.c_str());
9683  }
9684  vtable[method_index] = method;
9685  }
9686  return method;
9687  }
9688 private:
9689  mutable swig::SwigVar_PyObject vtable[1];
9690 #endif
9691 
9692 };
9693 
9694 
9696 
9697 public:
9698  SwigDirector_BeamShape(PyObject *self);
9699  virtual ~SwigDirector_BeamShape();
9700  virtual void init(Pythia8::Settings &settings, Pythia8::Rndm *rndmPtrIn);
9701  virtual void pick();
9702  using Pythia8::BeamShape::deltaPxA;
9703  using Pythia8::BeamShape::deltaPyA;
9704  using Pythia8::BeamShape::deltaPzA;
9705  using Pythia8::BeamShape::deltaPxB;
9706  using Pythia8::BeamShape::deltaPyB;
9707  using Pythia8::BeamShape::deltaPzB;
9708  using Pythia8::BeamShape::vertexX;
9709  using Pythia8::BeamShape::vertexY;
9710  using Pythia8::BeamShape::vertexZ;
9711  using Pythia8::BeamShape::vertexT;
9712  using Pythia8::BeamShape::allowMomentumSpread;
9713  using Pythia8::BeamShape::allowVertexSpread;
9714  using Pythia8::BeamShape::sigmaPxA;
9715  using Pythia8::BeamShape::sigmaPyA;
9716  using Pythia8::BeamShape::sigmaPzA;
9717  using Pythia8::BeamShape::maxDevA;
9718  using Pythia8::BeamShape::sigmaPxB;
9719  using Pythia8::BeamShape::sigmaPyB;
9720  using Pythia8::BeamShape::sigmaPzB;
9721  using Pythia8::BeamShape::maxDevB;
9722  using Pythia8::BeamShape::sigmaVertexX;
9723  using Pythia8::BeamShape::sigmaVertexY;
9724  using Pythia8::BeamShape::sigmaVertexZ;
9725  using Pythia8::BeamShape::maxDevVertex;
9726  using Pythia8::BeamShape::sigmaTime;
9727  using Pythia8::BeamShape::maxDevTime;
9728  using Pythia8::BeamShape::offsetX;
9729  using Pythia8::BeamShape::offsetY;
9730  using Pythia8::BeamShape::offsetZ;
9731  using Pythia8::BeamShape::offsetT;
9732  using Pythia8::BeamShape::rndmPtr;
9733 
9734 /* Internal director utilities */
9735 public:
9736  bool swig_get_inner(const char *swig_protected_method_name) const {
9737  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
9738  return (iv != swig_inner.end() ? iv->second : false);
9739  }
9740  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
9741  swig_inner[swig_protected_method_name] = swig_val;
9742  }
9743 private:
9744  mutable std::map<std::string, bool> swig_inner;
9745 
9746 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
9747 /* VTable implementation */
9748  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
9749  PyObject *method = vtable[method_index];
9750  if (!method) {
9751  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
9752  method = PyObject_GetAttr(swig_get_self(), name);
9753  if (!method) {
9754  std::string msg = "Method in class BeamShape doesn't exist, undefined ";
9755  msg += method_name;
9756  Swig::DirectorMethodException::raise(msg.c_str());
9757  }
9758  vtable[method_index] = method;
9759  }
9760  return method;
9761  }
9762 private:
9763  mutable swig::SwigVar_PyObject vtable[2];
9764 #endif
9765 
9766 };
9767 
9768 
9770 
9771 public:
9772  SwigDirector_PDF(PyObject *self, int idBeamIn = 2212);
9773  virtual ~SwigDirector_PDF();
9774  virtual bool isSetup();
9775  virtual void newValenceContent(int idVal1In, int idVal2In);
9776  virtual void setExtrapolate(bool arg0);
9777  virtual double xf(int id, double x, double Q2);
9778  virtual double xfVal(int id, double x, double Q2);
9779  virtual double xfSea(int id, double x, double Q2);
9780  virtual bool insideBounds(double arg0, double arg1);
9781  virtual double alphaS(double arg0);
9782  virtual double mQuarkPDF(int arg0);
9783  virtual int nMembers();
9784  virtual void calcPDFEnvelope(int arg0, double arg1, double arg2, int arg3);
9785  virtual void calcPDFEnvelope(std::pair< int,int > arg0, std::pair< double,double > arg1, double arg2, int arg3);
9786  virtual Pythia8::PDF::PDFEnvelope getPDFEnvelope();
9787  virtual double gammaPDFxDependence(int arg0, double arg1);
9788  virtual double gammaPDFRefScale(int arg0);
9789  virtual int sampleGammaValFlavor(double arg0);
9790  virtual double xfIntegratedTotal(double arg0);
9791  virtual double xGamma();
9792  virtual void xPom(double arg0 = -1.0);
9793  virtual double xfFlux(int arg0, double arg1, double arg2);
9794  virtual double xfApprox(int arg0, double arg1, double arg2);
9795  virtual double xfGamma(int arg0, double arg1, double arg2);
9796  virtual double intFluxApprox();
9797  virtual double getXmin();
9798  virtual double getXhadr();
9799  virtual double sampleXgamma(double arg0);
9800  virtual double sampleQ2gamma(double arg0);
9801  virtual double xfMax(int id, double x, double Q2);
9802  virtual double xfSame(int id, double x, double Q2);
9803  virtual void setVMDscale(double arg0 = 1.);
9804  virtual void xfUpdate(int id, double x, double Q2);
9805  using Pythia8::PDF::idBeam;
9806  using Pythia8::PDF::idBeamAbs;
9807  using Pythia8::PDF::idSav;
9808  using Pythia8::PDF::idVal1;
9809  using Pythia8::PDF::idVal2;
9810  using Pythia8::PDF::xSav;
9811  using Pythia8::PDF::Q2Sav;
9812  using Pythia8::PDF::xu;
9813  using Pythia8::PDF::xd;
9814  using Pythia8::PDF::xs;
9815  using Pythia8::PDF::xubar;
9816  using Pythia8::PDF::xdbar;
9817  using Pythia8::PDF::xsbar;
9818  using Pythia8::PDF::xc;
9819  using Pythia8::PDF::xb;
9820  using Pythia8::PDF::xg;
9821  using Pythia8::PDF::xlepton;
9822  using Pythia8::PDF::xgamma;
9823  using Pythia8::PDF::xuVal;
9824  using Pythia8::PDF::xuSea;
9825  using Pythia8::PDF::xdVal;
9826  using Pythia8::PDF::xdSea;
9827  using Pythia8::PDF::isSet;
9828  using Pythia8::PDF::isInit;
9829  using Pythia8::PDF::xsVal;
9830  using Pythia8::PDF::xcVal;
9831  using Pythia8::PDF::xbVal;
9832  using Pythia8::PDF::xsSea;
9833  using Pythia8::PDF::xcSea;
9834  using Pythia8::PDF::xbSea;
9835  using Pythia8::PDF::hasGammaInLepton;
9836  using Pythia8::PDF::setValenceContent;
9837  using Pythia8::PDF::printErr;
9838 
9839 /* Internal director utilities */
9840 public:
9841  bool swig_get_inner(const char *swig_protected_method_name) const {
9842  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
9843  return (iv != swig_inner.end() ? iv->second : false);
9844  }
9845  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
9846  swig_inner[swig_protected_method_name] = swig_val;
9847  }
9848 private:
9849  mutable std::map<std::string, bool> swig_inner;
9850 
9851 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
9852 /* VTable implementation */
9853  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
9854  PyObject *method = vtable[method_index];
9855  if (!method) {
9856  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
9857  method = PyObject_GetAttr(swig_get_self(), name);
9858  if (!method) {
9859  std::string msg = "Method in class PDF doesn't exist, undefined ";
9860  msg += method_name;
9861  Swig::DirectorMethodException::raise(msg.c_str());
9862  }
9863  vtable[method_index] = method;
9864  }
9865  return method;
9866  }
9867 private:
9868  mutable swig::SwigVar_PyObject vtable[33];
9869 #endif
9870 
9871 };
9872 
9873 
9875 
9876 public:
9877  SwigDirector_ResonanceWidths(PyObject *self);
9878  virtual ~SwigDirector_ResonanceWidths();
9879  virtual bool init(Pythia8::Info *infoPtrIn, Pythia8::Settings *settingsPtrIn, Pythia8::ParticleData *particleDataPtrIn, Pythia8::Couplings *couplingsPtrIn);
9880  virtual void initConstants();
9881  virtual void initConstantsSwigPublic() {
9882  Pythia8::ResonanceWidths::initConstants();
9883  }
9884  virtual bool initBSM();
9885  virtual bool initBSMSwigPublic() {
9886  return Pythia8::ResonanceWidths::initBSM();
9887  }
9888  virtual bool allowCalc();
9889  virtual bool allowCalcSwigPublic() {
9890  return Pythia8::ResonanceWidths::allowCalc();
9891  }
9892  virtual void calcPreFac(bool arg0 = false);
9893  virtual void calcPreFacSwigPublic(bool arg0 = false) {
9894  Pythia8::ResonanceWidths::calcPreFac(arg0);
9895  }
9896  virtual void calcWidth(bool arg0 = false);
9897  virtual void calcWidthSwigPublic(bool arg0 = false) {
9898  Pythia8::ResonanceWidths::calcWidth(arg0);
9899  }
9900  using Pythia8::ResonanceWidths::NPOINT;
9901  using Pythia8::ResonanceWidths::MASSMIN;
9902  using Pythia8::ResonanceWidths::MASSMARGIN;
9903  using Pythia8::ResonanceWidths::idRes;
9904  using Pythia8::ResonanceWidths::hasAntiRes;
9905  using Pythia8::ResonanceWidths::doForceWidth;
9906  using Pythia8::ResonanceWidths::isGeneric;
9907  using Pythia8::ResonanceWidths::allowCalcWidth;
9908  using Pythia8::ResonanceWidths::minWidth;
9909  using Pythia8::ResonanceWidths::minThreshold;
9910  using Pythia8::ResonanceWidths::mRes;
9911  using Pythia8::ResonanceWidths::GammaRes;
9912  using Pythia8::ResonanceWidths::m2Res;
9913  using Pythia8::ResonanceWidths::GamMRat;
9914  using Pythia8::ResonanceWidths::openPos;
9915  using Pythia8::ResonanceWidths::openNeg;
9916  using Pythia8::ResonanceWidths::forceFactor;
9917  using Pythia8::ResonanceWidths::iChannel;
9918  using Pythia8::ResonanceWidths::onMode;
9919  using Pythia8::ResonanceWidths::meMode;
9920  using Pythia8::ResonanceWidths::mult;
9921  using Pythia8::ResonanceWidths::id1;
9922  using Pythia8::ResonanceWidths::id2;
9923  using Pythia8::ResonanceWidths::id3;
9924  using Pythia8::ResonanceWidths::id1Abs;
9925  using Pythia8::ResonanceWidths::id2Abs;
9926  using Pythia8::ResonanceWidths::id3Abs;
9927  using Pythia8::ResonanceWidths::idInFlav;
9928  using Pythia8::ResonanceWidths::widNow;
9929  using Pythia8::ResonanceWidths::mHat;
9930  using Pythia8::ResonanceWidths::mf1;
9931  using Pythia8::ResonanceWidths::mf2;
9932  using Pythia8::ResonanceWidths::mf3;
9933  using Pythia8::ResonanceWidths::mr1;
9934  using Pythia8::ResonanceWidths::mr2;
9935  using Pythia8::ResonanceWidths::mr3;
9936  using Pythia8::ResonanceWidths::ps;
9937  using Pythia8::ResonanceWidths::kinFac;
9938  using Pythia8::ResonanceWidths::alpEM;
9939  using Pythia8::ResonanceWidths::alpS;
9940  using Pythia8::ResonanceWidths::colQ;
9941  using Pythia8::ResonanceWidths::preFac;
9942  using Pythia8::ResonanceWidths::particlePtr;
9943  using Pythia8::ResonanceWidths::infoPtr;
9944  using Pythia8::ResonanceWidths::settingsPtr;
9945  using Pythia8::ResonanceWidths::particleDataPtr;
9946  using Pythia8::ResonanceWidths::couplingsPtr;
9947  using Pythia8::ResonanceWidths::numInt1BW;
9948  using Pythia8::ResonanceWidths::numInt2BW;
9949 
9950 /* Internal director utilities */
9951 public:
9952  bool swig_get_inner(const char *swig_protected_method_name) const {
9953  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
9954  return (iv != swig_inner.end() ? iv->second : false);
9955  }
9956  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
9957  swig_inner[swig_protected_method_name] = swig_val;
9958  }
9959 private:
9960  mutable std::map<std::string, bool> swig_inner;
9961 
9962 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
9963 /* VTable implementation */
9964  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
9965  PyObject *method = vtable[method_index];
9966  if (!method) {
9967  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
9968  method = PyObject_GetAttr(swig_get_self(), name);
9969  if (!method) {
9970  std::string msg = "Method in class ResonanceWidths doesn't exist, undefined ";
9971  msg += method_name;
9972  Swig::DirectorMethodException::raise(msg.c_str());
9973  }
9974  vtable[method_index] = method;
9975  }
9976  return method;
9977  }
9978 private:
9979  mutable swig::SwigVar_PyObject vtable[8];
9980 #endif
9981 
9982 };
9983 
9984 
9986 
9987 public:
9988  SwigDirector_LHAup(PyObject *self, int strategyIn = 3);
9989  virtual ~SwigDirector_LHAup();
9990  virtual void newEventFile(char const *arg0);
9991  virtual bool fileFound();
9992  virtual bool useExternal();
9993  virtual bool setInit();
9994  virtual bool setEvent(int idProcIn = 0);
9995  virtual bool skipEvent(int nSkip);
9996  virtual bool openLHEF(std::string fileNameIn);
9997  virtual bool closeLHEF(bool updateInit = false);
9998  using Pythia8::LHAup::CONVERTMB2PB;
9999  using Pythia8::LHAup::infoPtr;
10000  using Pythia8::LHAup::setBeamA;
10001  using Pythia8::LHAup::setBeamB;
10002  using Pythia8::LHAup::setStrategy;
10003  using Pythia8::LHAup::addProcess;
10004  using Pythia8::LHAup::setXSec;
10005  using Pythia8::LHAup::setXErr;
10006  using Pythia8::LHAup::setXMax;
10007  using Pythia8::LHAup::setProcess;
10008  using Pythia8::LHAup::addParticle;
10009  using Pythia8::LHAup::setIdX;
10010  using Pythia8::LHAup::setPdf;
10011  using Pythia8::LHAup::setInitLHEF;
10012  using Pythia8::LHAup::setNewEventLHEF;
10013  using Pythia8::LHAup::setOldEventLHEF;
10014  using Pythia8::LHAup::openFile;
10015  using Pythia8::LHAup::closeFile;
10016  using Pythia8::LHAup::setInfoHeader;
10017  using Pythia8::LHAup::nupSave;
10018  using Pythia8::LHAup::idprupSave;
10019  using Pythia8::LHAup::xwgtupSave;
10020  using Pythia8::LHAup::scalupSave;
10021  using Pythia8::LHAup::aqedupSave;
10022  using Pythia8::LHAup::aqcdupSave;
10023  using Pythia8::LHAup::xSecSumSave;
10024  using Pythia8::LHAup::xErrSumSave;
10025  using Pythia8::LHAup::particlesSave;
10026  using Pythia8::LHAup::getPDFSave;
10027  using Pythia8::LHAup::getScale;
10028  using Pythia8::LHAup::id1InSave;
10029  using Pythia8::LHAup::id2InSave;
10030  using Pythia8::LHAup::id1pdfInSave;
10031  using Pythia8::LHAup::id2pdfInSave;
10032  using Pythia8::LHAup::x1InSave;
10033  using Pythia8::LHAup::x2InSave;
10034  using Pythia8::LHAup::x1pdfInSave;
10035  using Pythia8::LHAup::x2pdfInSave;
10036  using Pythia8::LHAup::scalePDFInSave;
10037  using Pythia8::LHAup::pdf1InSave;
10038  using Pythia8::LHAup::pdf2InSave;
10039  using Pythia8::LHAup::fileName;
10040  using Pythia8::LHAup::dateNow;
10041  using Pythia8::LHAup::timeNow;
10042 
10043 /* Internal director utilities */
10044 public:
10045  bool swig_get_inner(const char *swig_protected_method_name) const {
10046  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
10047  return (iv != swig_inner.end() ? iv->second : false);
10048  }
10049  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
10050  swig_inner[swig_protected_method_name] = swig_val;
10051  }
10052 private:
10053  mutable std::map<std::string, bool> swig_inner;
10054 
10055 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
10056 /* VTable implementation */
10057  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
10058  PyObject *method = vtable[method_index];
10059  if (!method) {
10060  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
10061  method = PyObject_GetAttr(swig_get_self(), name);
10062  if (!method) {
10063  std::string msg = "Method in class LHAup doesn't exist, undefined ";
10064  msg += method_name;
10065  Swig::DirectorMethodException::raise(msg.c_str());
10066  }
10067  vtable[method_index] = method;
10068  }
10069  return method;
10070  }
10071 private:
10072  mutable swig::SwigVar_PyObject vtable[10];
10073 #endif
10074 
10075 };
10076 
10077 
10079 
10080 public:
10081  SwigDirector_MergingHooks(PyObject *self);
10082  virtual ~SwigDirector_MergingHooks();
10083  virtual double tmsDefinition(Pythia8::Event const &event);
10084  virtual double dampenIfFailCuts(Pythia8::Event const &inEvent);
10085  virtual bool canCutOnRecState();
10086  virtual bool doCutOnRecState(Pythia8::Event const &event);
10087  virtual bool canVetoTrialEmission();
10088  virtual bool doVetoTrialEmission(Pythia8::Event const &arg0, Pythia8::Event const &arg1);
10089  virtual double hardProcessME(Pythia8::Event const &inEvent);
10090  virtual void init();
10091  virtual int getNumberOfClusteringSteps(Pythia8::Event const &event, bool resetNjetMax = false);
10092  virtual double tmsNow(Pythia8::Event const &event);
10093  virtual bool canVetoEmission();
10094  virtual bool doVetoEmission(Pythia8::Event const &arg0);
10095  virtual bool useShowerPlugin();
10096  virtual bool canVetoStep();
10097  virtual bool doVetoStep(Pythia8::Event const &process, Pythia8::Event const &event, bool doResonance = false);
10098  virtual bool setShowerStartingScales(bool isTrial, bool doMergeFirstEmm, double &pTscaleIn, Pythia8::Event const &event, double &pTmaxFSRIn, bool &limitPTmaxFSRin, double &pTmaxISRIn, bool &limitPTmaxISRin, double &pTmaxMPIIn, bool &limitPTmaxMPIin);
10099 
10100 /* Internal director utilities */
10101 public:
10102  bool swig_get_inner(const char *swig_protected_method_name) const {
10103  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
10104  return (iv != swig_inner.end() ? iv->second : false);
10105  }
10106  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
10107  swig_inner[swig_protected_method_name] = swig_val;
10108  }
10109 private:
10110  mutable std::map<std::string, bool> swig_inner;
10111 
10112 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
10113 /* VTable implementation */
10114  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
10115  PyObject *method = vtable[method_index];
10116  if (!method) {
10117  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
10118  method = PyObject_GetAttr(swig_get_self(), name);
10119  if (!method) {
10120  std::string msg = "Method in class MergingHooks doesn't exist, undefined ";
10121  msg += method_name;
10122  Swig::DirectorMethodException::raise(msg.c_str());
10123  }
10124  vtable[method_index] = method;
10125  }
10126  return method;
10127  }
10128 private:
10129  mutable swig::SwigVar_PyObject vtable[18];
10130 #endif
10131 
10132 };
10133 
10134 
10136 
10137 public:
10138  SwigDirector_SigmaProcess(PyObject *self);
10139  virtual ~SwigDirector_SigmaProcess();
10140  virtual void initProc();
10141  virtual bool initFlux();
10142  virtual void set1Kin(double arg0, double arg1, double arg2);
10143  virtual void set2Kin(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, double arg7);
10144  virtual void set2KinMPI(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, bool arg7, double arg8, double arg9);
10145  virtual void set3Kin(double arg0, double arg1, double arg2, Pythia8::Vec4 arg3, Pythia8::Vec4 arg4, Pythia8::Vec4 arg5, double arg6, double arg7, double arg8, double arg9, double arg10, double arg11);
10146  virtual void sigmaKin();
10147  virtual double sigmaHat();
10148  virtual double sigmaHatWrap(int id1in = 0, int id2in = 0);
10149  virtual double sigmaPDF(bool initPS = false, bool samexGamma = false, bool useNewXvalues = false, double x1New = 0., double x2New = 0.);
10150  virtual void setIdColAcol();
10151  virtual bool final2KinMPI(int arg0 = 0, int arg1 = 0, Pythia8::Vec4 arg2 = 0., Pythia8::Vec4 arg3 = 0., double arg4 = 0., double arg5 = 0.);
10152  virtual double weightDecayFlav(Pythia8::Event &arg0);
10153  virtual double weightDecay(Pythia8::Event &arg0, int arg1, int arg2);
10154  virtual void setScale();
10155  virtual std::string name() const;
10156  virtual int code() const;
10157  virtual int nFinal() const;
10158  virtual std::string inFlux() const;
10159  virtual bool convert2mb() const;
10160  virtual bool convertM2() const;
10161  virtual bool isLHA() const;
10162  virtual bool isNonDiff() const;
10163  virtual bool isResolved() const;
10164  virtual bool isDiffA() const;
10165  virtual bool isDiffB() const;
10166  virtual bool isDiffC() const;
10167  virtual bool isSUSY() const;
10168  virtual bool allowNegativeSigma() const;
10169  virtual int id3Mass() const;
10170  virtual int id4Mass() const;
10171  virtual int id5Mass() const;
10172  virtual int resonanceA() const;
10173  virtual int resonanceB() const;
10174  virtual bool isSChannel() const;
10175  virtual int idSChannel() const;
10176  virtual bool isQCD3body() const;
10177  virtual int idTchan1() const;
10178  virtual int idTchan2() const;
10179  virtual double tChanFracPow1() const;
10180  virtual double tChanFracPow2() const;
10181  virtual bool useMirrorWeight() const;
10182  virtual int gmZmode() const;
10183  virtual void setIdInDiff(int arg0, int arg1);
10184  virtual bool setupForME();
10185  virtual bool setupForMESwigPublic() {
10186  return Pythia8::SigmaProcess::setupForME();
10187  }
10188  using Pythia8::SigmaProcess::CONVERT2MB;
10189  using Pythia8::SigmaProcess::MASSMARGIN;
10190  using Pythia8::SigmaProcess::COMPRELERR;
10191  using Pythia8::SigmaProcess::NCOMPSTEP;
10192  using Pythia8::SigmaProcess::infoPtr;
10193  using Pythia8::SigmaProcess::settingsPtr;
10194  using Pythia8::SigmaProcess::particleDataPtr;
10195  using Pythia8::SigmaProcess::rndmPtr;
10196  using Pythia8::SigmaProcess::beamAPtr;
10197  using Pythia8::SigmaProcess::beamBPtr;
10198  using Pythia8::SigmaProcess::couplingsPtr;
10199  using Pythia8::SigmaProcess::sigmaTotPtr;
10200  using Pythia8::SigmaProcess::slhaPtr;
10201  using Pythia8::SigmaProcess::lhaUpPtr;
10202  using Pythia8::SigmaProcess::nQuarkIn;
10203  using Pythia8::SigmaProcess::renormScale1;
10204  using Pythia8::SigmaProcess::renormScale2;
10205  using Pythia8::SigmaProcess::renormScale3;
10206  using Pythia8::SigmaProcess::renormScale3VV;
10207  using Pythia8::SigmaProcess::factorScale1;
10208  using Pythia8::SigmaProcess::factorScale2;
10209  using Pythia8::SigmaProcess::factorScale3;
10210  using Pythia8::SigmaProcess::factorScale3VV;
10211  using Pythia8::SigmaProcess::Kfactor;
10212  using Pythia8::SigmaProcess::mcME;
10213  using Pythia8::SigmaProcess::mbME;
10214  using Pythia8::SigmaProcess::mmuME;
10215  using Pythia8::SigmaProcess::mtauME;
10216  using Pythia8::SigmaProcess::renormMultFac;
10217  using Pythia8::SigmaProcess::renormFixScale;
10218  using Pythia8::SigmaProcess::factorMultFac;
10219  using Pythia8::SigmaProcess::factorFixScale;
10220  using Pythia8::SigmaProcess::higgsH1parity;
10221  using Pythia8::SigmaProcess::higgsH2parity;
10222  using Pythia8::SigmaProcess::higgsA3parity;
10223  using Pythia8::SigmaProcess::higgsH1eta;
10224  using Pythia8::SigmaProcess::higgsH2eta;
10225  using Pythia8::SigmaProcess::higgsA3eta;
10226  using Pythia8::SigmaProcess::higgsH1phi;
10227  using Pythia8::SigmaProcess::higgsH2phi;
10228  using Pythia8::SigmaProcess::higgsA3phi;
10229  using Pythia8::SigmaProcess::idA;
10230  using Pythia8::SigmaProcess::idB;
10231  using Pythia8::SigmaProcess::mA;
10232  using Pythia8::SigmaProcess::mB;
10233  using Pythia8::SigmaProcess::isLeptonA;
10234  using Pythia8::SigmaProcess::isLeptonB;
10235  using Pythia8::SigmaProcess::hasLeptonBeams;
10236  using Pythia8::SigmaProcess::lepton2gammaA;
10237  using Pythia8::SigmaProcess::lepton2gammaB;
10238  using Pythia8::SigmaProcess::inBeamA;
10239  using Pythia8::SigmaProcess::inBeamB;
10240  using Pythia8::SigmaProcess::addBeamA;
10241  using Pythia8::SigmaProcess::addBeamB;
10242  using Pythia8::SigmaProcess::sizeBeamA;
10243  using Pythia8::SigmaProcess::sizeBeamB;
10244  using Pythia8::SigmaProcess::inPair;
10245  using Pythia8::SigmaProcess::addPair;
10246  using Pythia8::SigmaProcess::sizePair;
10247  using Pythia8::SigmaProcess::mH;
10248  using Pythia8::SigmaProcess::sH;
10249  using Pythia8::SigmaProcess::sH2;
10250  using Pythia8::SigmaProcess::Q2RenSave;
10251  using Pythia8::SigmaProcess::alpEM;
10252  using Pythia8::SigmaProcess::alpS;
10253  using Pythia8::SigmaProcess::Q2FacSave;
10254  using Pythia8::SigmaProcess::x1Save;
10255  using Pythia8::SigmaProcess::x2Save;
10256  using Pythia8::SigmaProcess::pdf1Save;
10257  using Pythia8::SigmaProcess::pdf2Save;
10258  using Pythia8::SigmaProcess::sigmaSumSave;
10259  using Pythia8::SigmaProcess::id1;
10260  using Pythia8::SigmaProcess::id2;
10261  using Pythia8::SigmaProcess::id3;
10262  using Pythia8::SigmaProcess::id4;
10263  using Pythia8::SigmaProcess::id5;
10264  using Pythia8::SigmaProcess::idSave;
10265  using Pythia8::SigmaProcess::colSave;
10266  using Pythia8::SigmaProcess::acolSave;
10267  using Pythia8::SigmaProcess::mSave;
10268  using Pythia8::SigmaProcess::cosTheta;
10269  using Pythia8::SigmaProcess::sinTheta;
10270  using Pythia8::SigmaProcess::phi;
10271  using Pythia8::SigmaProcess::sHMass;
10272  using Pythia8::SigmaProcess::sHBeta;
10273  using Pythia8::SigmaProcess::pT2Mass;
10274  using Pythia8::SigmaProcess::pTFin;
10275  using Pythia8::SigmaProcess::parton;
10276  using Pythia8::SigmaProcess::partonT;
10277  using Pythia8::SigmaProcess::mSaveT;
10278  using Pythia8::SigmaProcess::pTFinT;
10279  using Pythia8::SigmaProcess::cosThetaT;
10280  using Pythia8::SigmaProcess::sinThetaT;
10281  using Pythia8::SigmaProcess::phiT;
10282  using Pythia8::SigmaProcess::setupForMEin;
10283  using Pythia8::SigmaProcess::mME;
10284  using Pythia8::SigmaProcess::pME;
10285  using Pythia8::SigmaProcess::swapTU;
10286  using Pythia8::SigmaProcess::setId;
10287  using Pythia8::SigmaProcess::setColAcol;
10288  using Pythia8::SigmaProcess::swapColAcol;
10289  using Pythia8::SigmaProcess::swapCol1234;
10290  using Pythia8::SigmaProcess::swapCol12;
10291  using Pythia8::SigmaProcess::swapCol34;
10292  using Pythia8::SigmaProcess::weightTopDecay;
10293  using Pythia8::SigmaProcess::weightHiggsDecay;
10294 
10295 /* Internal director utilities */
10296 public:
10297  bool swig_get_inner(const char *swig_protected_method_name) const {
10298  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
10299  return (iv != swig_inner.end() ? iv->second : false);
10300  }
10301  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
10302  swig_inner[swig_protected_method_name] = swig_val;
10303  }
10304 private:
10305  mutable std::map<std::string, bool> swig_inner;
10306 
10307 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
10308 /* VTable implementation */
10309  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
10310  PyObject *method = vtable[method_index];
10311  if (!method) {
10312  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
10313  method = PyObject_GetAttr(swig_get_self(), name);
10314  if (!method) {
10315  std::string msg = "Method in class SigmaProcess doesn't exist, undefined ";
10316  msg += method_name;
10317  Swig::DirectorMethodException::raise(msg.c_str());
10318  }
10319  vtable[method_index] = method;
10320  }
10321  return method;
10322  }
10323 private:
10324  mutable swig::SwigVar_PyObject vtable[58];
10325 #endif
10326 
10327 };
10328 
10329 
10331 
10332 public:
10333  SwigDirector_UserHooks(PyObject *self);
10334  virtual ~SwigDirector_UserHooks();
10335  virtual bool initAfterBeams();
10336  virtual bool canModifySigma();
10337  virtual double multiplySigmaBy(Pythia8::SigmaProcess const *sigmaProcessPtr, Pythia8::PhaseSpace const *phaseSpacePtr, bool inEvent);
10338  virtual bool canBiasSelection();
10339  virtual double biasSelectionBy(Pythia8::SigmaProcess const *sigmaProcessPtr, Pythia8::PhaseSpace const *phaseSpacePtr, bool inEvent);
10340  virtual double biasedSelectionWeight();
10341  virtual bool canVetoProcessLevel();
10342  virtual bool doVetoProcessLevel(Pythia8::Event &arg0);
10343  virtual bool canVetoResonanceDecays();
10344  virtual bool doVetoResonanceDecays(Pythia8::Event &arg0);
10345  virtual bool canVetoPT();
10346  virtual double scaleVetoPT();
10347  virtual bool doVetoPT(int arg0, Pythia8::Event const &arg1);
10348  virtual bool canVetoStep();
10349  virtual int numberVetoStep();
10350  virtual bool doVetoStep(int arg0, int arg1, int arg2, Pythia8::Event const &arg3);
10351  virtual bool canVetoMPIStep();
10352  virtual int numberVetoMPIStep();
10353  virtual bool doVetoMPIStep(int arg0, Pythia8::Event const &arg1);
10354  virtual bool canVetoPartonLevelEarly();
10355  virtual bool doVetoPartonLevelEarly(Pythia8::Event const &arg0);
10356  virtual bool retryPartonLevel();
10357  virtual bool canVetoPartonLevel();
10358  virtual bool doVetoPartonLevel(Pythia8::Event const &arg0);
10359  virtual bool canSetResonanceScale();
10360  virtual double scaleResonance(int arg0, Pythia8::Event const &arg1);
10361  virtual bool canVetoISREmission();
10362  virtual bool doVetoISREmission(int arg0, Pythia8::Event const &arg1, int arg2);
10363  virtual bool canVetoFSREmission();
10364  virtual bool doVetoFSREmission(int arg0, Pythia8::Event const &arg1, int arg2, bool arg3 = false);
10365  virtual bool canVetoMPIEmission();
10366  virtual bool doVetoMPIEmission(int arg0, Pythia8::Event const &arg1);
10367  virtual bool canReconnectResonanceSystems();
10368  virtual bool doReconnectResonanceSystems(int arg0, Pythia8::Event &arg1);
10369  virtual bool canEnhanceEmission();
10370  virtual double enhanceFactor(std::string arg0);
10371  virtual double vetoProbability(std::string arg0);
10372  virtual bool canEnhanceTrial();
10373  virtual bool canChangeFragPar();
10374  virtual void setStringEnds(Pythia8::StringEnd const *arg0, Pythia8::StringEnd const *arg1, std::vector< int,std::allocator< int > > arg2);
10375  virtual bool doChangeFragPar(Pythia8::StringFlav *arg0, Pythia8::StringZ *arg1, Pythia8::StringPT *arg2, int arg3, double arg4, std::vector< int,std::allocator< int > > arg5, Pythia8::StringEnd const *arg6);
10376  virtual bool doVetoFragmentation(Pythia8::Particle arg0, Pythia8::StringEnd const *arg1);
10377  virtual bool doVetoFragmentation(Pythia8::Particle arg0, Pythia8::Particle arg1, Pythia8::StringEnd const *arg2, Pythia8::StringEnd const *arg3);
10378  virtual bool canSetImpactParameter() const;
10379  virtual double doSetImpactParameter();
10380  using Pythia8::UserHooks::infoPtr;
10381  using Pythia8::UserHooks::settingsPtr;
10382  using Pythia8::UserHooks::particleDataPtr;
10383  using Pythia8::UserHooks::rndmPtr;
10384  using Pythia8::UserHooks::beamAPtr;
10385  using Pythia8::UserHooks::beamBPtr;
10386  using Pythia8::UserHooks::beamPomAPtr;
10387  using Pythia8::UserHooks::beamPomBPtr;
10388  using Pythia8::UserHooks::coupSMPtr;
10389  using Pythia8::UserHooks::partonSystemsPtr;
10390  using Pythia8::UserHooks::sigmaTotPtr;
10391  using Pythia8::UserHooks::omitResonanceDecays;
10392  using Pythia8::UserHooks::subEvent;
10393  using Pythia8::UserHooks::workEvent;
10394  using Pythia8::UserHooks::selBias;
10395  using Pythia8::UserHooks::enhancedEventWeight;
10396  using Pythia8::UserHooks::pTEnhanced;
10397  using Pythia8::UserHooks::wtEnhanced;
10398 
10399 /* Internal director utilities */
10400 public:
10401  bool swig_get_inner(const char *swig_protected_method_name) const {
10402  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
10403  return (iv != swig_inner.end() ? iv->second : false);
10404  }
10405  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
10406  swig_inner[swig_protected_method_name] = swig_val;
10407  }
10408 private:
10409  mutable std::map<std::string, bool> swig_inner;
10410 
10411 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
10412 /* VTable implementation */
10413  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
10414  PyObject *method = vtable[method_index];
10415  if (!method) {
10416  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
10417  method = PyObject_GetAttr(swig_get_self(), name);
10418  if (!method) {
10419  std::string msg = "Method in class UserHooks doesn't exist, undefined ";
10420  msg += method_name;
10421  Swig::DirectorMethodException::raise(msg.c_str());
10422  }
10423  vtable[method_index] = method;
10424  }
10425  return method;
10426  }
10427 private:
10428  mutable swig::SwigVar_PyObject vtable[46];
10429 #endif
10430 
10431 };
10432 
10433 
10435 
10436 public:
10437  SwigDirector_PhaseSpace(PyObject *self);
10438  virtual ~SwigDirector_PhaseSpace();
10439  virtual bool setupSampling();
10440  virtual bool trialKin(bool inEvent = true, bool repeatSame = false);
10441  virtual bool finalKin();
10442  virtual double sigmaSumSigned() const;
10443  virtual bool isResolved() const;
10444  virtual void rescaleSigma(double arg0);
10445  virtual void rescaleMomenta(double arg0);
10446  virtual double weightGammaPDFApprox();
10447  virtual void setGammaKinPtr(Pythia8::GammaKinematics *gammaKinPtrIn);
10448  using Pythia8::PhaseSpace::NMAXTRY;
10449  using Pythia8::PhaseSpace::NTRY3BODY;
10450  using Pythia8::PhaseSpace::SAFETYMARGIN;
10451  using Pythia8::PhaseSpace::TINY;
10452  using Pythia8::PhaseSpace::EVENFRAC;
10453  using Pythia8::PhaseSpace::SAMESIGMA;
10454  using Pythia8::PhaseSpace::MRESMINABS;
10455  using Pythia8::PhaseSpace::WIDTHMARGIN;
10456  using Pythia8::PhaseSpace::SAMEMASS;
10457  using Pythia8::PhaseSpace::MASSMARGIN;
10458  using Pythia8::PhaseSpace::EXTRABWWTMAX;
10459  using Pythia8::PhaseSpace::THRESHOLDSIZE;
10460  using Pythia8::PhaseSpace::THRESHOLDSTEP;
10461  using Pythia8::PhaseSpace::YRANGEMARGIN;
10462  using Pythia8::PhaseSpace::LEPTONXMIN;
10463  using Pythia8::PhaseSpace::LEPTONXMAX;
10464  using Pythia8::PhaseSpace::LEPTONXLOGMIN;
10465  using Pythia8::PhaseSpace::LEPTONXLOGMAX;
10466  using Pythia8::PhaseSpace::LEPTONTAUMIN;
10467  using Pythia8::PhaseSpace::SHATMINZ;
10468  using Pythia8::PhaseSpace::PT2RATMINZ;
10469  using Pythia8::PhaseSpace::WTCORRECTION;
10470  using Pythia8::PhaseSpace::sigmaProcessPtr;
10471  using Pythia8::PhaseSpace::infoPtr;
10472  using Pythia8::PhaseSpace::settingsPtr;
10473  using Pythia8::PhaseSpace::particleDataPtr;
10474  using Pythia8::PhaseSpace::rndmPtr;
10475  using Pythia8::PhaseSpace::beamAPtr;
10476  using Pythia8::PhaseSpace::beamBPtr;
10477  using Pythia8::PhaseSpace::couplingsPtr;
10478  using Pythia8::PhaseSpace::sigmaTotPtr;
10479  using Pythia8::PhaseSpace::userHooksPtr;
10480  using Pythia8::PhaseSpace::lhaUpPtr;
10481  using Pythia8::PhaseSpace::gammaKinPtr;
10482  using Pythia8::PhaseSpace::useBreitWigners;
10483  using Pythia8::PhaseSpace::doEnergySpread;
10484  using Pythia8::PhaseSpace::showSearch;
10485  using Pythia8::PhaseSpace::showViolation;
10486  using Pythia8::PhaseSpace::increaseMaximum;
10487  using Pythia8::PhaseSpace::hasQ2Min;
10488  using Pythia8::PhaseSpace::gmZmodeGlobal;
10489  using Pythia8::PhaseSpace::mHatGlobalMin;
10490  using Pythia8::PhaseSpace::mHatGlobalMax;
10491  using Pythia8::PhaseSpace::pTHatGlobalMin;
10492  using Pythia8::PhaseSpace::pTHatGlobalMax;
10493  using Pythia8::PhaseSpace::Q2GlobalMin;
10494  using Pythia8::PhaseSpace::pTHatMinDiverge;
10495  using Pythia8::PhaseSpace::minWidthBreitWigners;
10496  using Pythia8::PhaseSpace::minWidthNarrowBW;
10497  using Pythia8::PhaseSpace::idA;
10498  using Pythia8::PhaseSpace::idB;
10499  using Pythia8::PhaseSpace::idAin;
10500  using Pythia8::PhaseSpace::idBin;
10501  using Pythia8::PhaseSpace::mA;
10502  using Pythia8::PhaseSpace::mB;
10503  using Pythia8::PhaseSpace::eCM;
10504  using Pythia8::PhaseSpace::s;
10505  using Pythia8::PhaseSpace::sigmaMxGm;
10506  using Pythia8::PhaseSpace::hasLeptonBeamA;
10507  using Pythia8::PhaseSpace::hasLeptonBeamB;
10508  using Pythia8::PhaseSpace::hasOneLeptonBeam;
10509  using Pythia8::PhaseSpace::hasTwoLeptonBeams;
10510  using Pythia8::PhaseSpace::hasPointGammaA;
10511  using Pythia8::PhaseSpace::hasPointGammaB;
10512  using Pythia8::PhaseSpace::hasOnePointParticle;
10513  using Pythia8::PhaseSpace::hasTwoPointParticles;
10514  using Pythia8::PhaseSpace::hasGamma;
10515  using Pythia8::PhaseSpace::newSigmaMx;
10516  using Pythia8::PhaseSpace::canModifySigma;
10517  using Pythia8::PhaseSpace::canBiasSelection;
10518  using Pythia8::PhaseSpace::canBias2Sel;
10519  using Pythia8::PhaseSpace::gmZmode;
10520  using Pythia8::PhaseSpace::bias2SelPow;
10521  using Pythia8::PhaseSpace::bias2SelRef;
10522  using Pythia8::PhaseSpace::wtBW;
10523  using Pythia8::PhaseSpace::sigmaNw;
10524  using Pythia8::PhaseSpace::sigmaMx;
10525  using Pythia8::PhaseSpace::sigmaPos;
10526  using Pythia8::PhaseSpace::sigmaNeg;
10527  using Pythia8::PhaseSpace::biasWt;
10528  using Pythia8::PhaseSpace::mHatMin;
10529  using Pythia8::PhaseSpace::mHatMax;
10530  using Pythia8::PhaseSpace::sHatMin;
10531  using Pythia8::PhaseSpace::sHatMax;
10532  using Pythia8::PhaseSpace::pTHatMin;
10533  using Pythia8::PhaseSpace::pTHatMax;
10534  using Pythia8::PhaseSpace::pT2HatMin;
10535  using Pythia8::PhaseSpace::pT2HatMax;
10536  using Pythia8::PhaseSpace::x1H;
10537  using Pythia8::PhaseSpace::x2H;
10538  using Pythia8::PhaseSpace::m3;
10539  using Pythia8::PhaseSpace::m4;
10540  using Pythia8::PhaseSpace::m5;
10541  using Pythia8::PhaseSpace::s3;
10542  using Pythia8::PhaseSpace::s4;
10543  using Pythia8::PhaseSpace::s5;
10544  using Pythia8::PhaseSpace::mHat;
10545  using Pythia8::PhaseSpace::sH;
10546  using Pythia8::PhaseSpace::tH;
10547  using Pythia8::PhaseSpace::uH;
10548  using Pythia8::PhaseSpace::pAbs;
10549  using Pythia8::PhaseSpace::p2Abs;
10550  using Pythia8::PhaseSpace::pTH;
10551  using Pythia8::PhaseSpace::theta;
10552  using Pythia8::PhaseSpace::phi;
10553  using Pythia8::PhaseSpace::betaZ;
10554  using Pythia8::PhaseSpace::pH;
10555  using Pythia8::PhaseSpace::mH;
10556  using Pythia8::PhaseSpace::decayKinematicsStep;
10557  using Pythia8::PhaseSpace::setup3Body;
10558  using Pythia8::PhaseSpace::setupSampling123;
10559  using Pythia8::PhaseSpace::trialKin123;
10560  using Pythia8::PhaseSpace::idResA;
10561  using Pythia8::PhaseSpace::idResB;
10562  using Pythia8::PhaseSpace::mResA;
10563  using Pythia8::PhaseSpace::mResB;
10564  using Pythia8::PhaseSpace::GammaResA;
10565  using Pythia8::PhaseSpace::GammaResB;
10566  using Pythia8::PhaseSpace::tauResA;
10567  using Pythia8::PhaseSpace::tauResB;
10568  using Pythia8::PhaseSpace::widResA;
10569  using Pythia8::PhaseSpace::widResB;
10570  using Pythia8::PhaseSpace::sameResMass;
10571  using Pythia8::PhaseSpace::useMirrorWeight;
10572  using Pythia8::PhaseSpace::hasNegZ;
10573  using Pythia8::PhaseSpace::hasPosZ;
10574  using Pythia8::PhaseSpace::tau;
10575  using Pythia8::PhaseSpace::y;
10576  using Pythia8::PhaseSpace::z;
10577  using Pythia8::PhaseSpace::tauMin;
10578  using Pythia8::PhaseSpace::tauMax;
10579  using Pythia8::PhaseSpace::yMax;
10580  using Pythia8::PhaseSpace::zMin;
10581  using Pythia8::PhaseSpace::zMax;
10582  using Pythia8::PhaseSpace::ratio34;
10583  using Pythia8::PhaseSpace::unity34;
10584  using Pythia8::PhaseSpace::zNeg;
10585  using Pythia8::PhaseSpace::zPos;
10586  using Pythia8::PhaseSpace::wtTau;
10587  using Pythia8::PhaseSpace::wtY;
10588  using Pythia8::PhaseSpace::wtZ;
10589  using Pythia8::PhaseSpace::wt3Body;
10590  using Pythia8::PhaseSpace::runBW3H;
10591  using Pythia8::PhaseSpace::runBW4H;
10592  using Pythia8::PhaseSpace::runBW5H;
10593  using Pythia8::PhaseSpace::intTau0;
10594  using Pythia8::PhaseSpace::intTau1;
10595  using Pythia8::PhaseSpace::intTau2;
10596  using Pythia8::PhaseSpace::intTau3;
10597  using Pythia8::PhaseSpace::intTau4;
10598  using Pythia8::PhaseSpace::intTau5;
10599  using Pythia8::PhaseSpace::intTau6;
10600  using Pythia8::PhaseSpace::intY0;
10601  using Pythia8::PhaseSpace::intY12;
10602  using Pythia8::PhaseSpace::intY34;
10603  using Pythia8::PhaseSpace::intY56;
10604  using Pythia8::PhaseSpace::mTchan1;
10605  using Pythia8::PhaseSpace::sTchan1;
10606  using Pythia8::PhaseSpace::mTchan2;
10607  using Pythia8::PhaseSpace::sTchan2;
10608  using Pythia8::PhaseSpace::frac3Flat;
10609  using Pythia8::PhaseSpace::frac3Pow1;
10610  using Pythia8::PhaseSpace::frac3Pow2;
10611  using Pythia8::PhaseSpace::zNegMin;
10612  using Pythia8::PhaseSpace::zNegMax;
10613  using Pythia8::PhaseSpace::zPosMin;
10614  using Pythia8::PhaseSpace::zPosMax;
10615  using Pythia8::PhaseSpace::p3cm;
10616  using Pythia8::PhaseSpace::p4cm;
10617  using Pythia8::PhaseSpace::p5cm;
10618  using Pythia8::PhaseSpace::nTau;
10619  using Pythia8::PhaseSpace::nY;
10620  using Pythia8::PhaseSpace::nZ;
10621  using Pythia8::PhaseSpace::tauCoef;
10622  using Pythia8::PhaseSpace::yCoef;
10623  using Pythia8::PhaseSpace::zCoef;
10624  using Pythia8::PhaseSpace::tauCoefSum;
10625  using Pythia8::PhaseSpace::yCoefSum;
10626  using Pythia8::PhaseSpace::zCoefSum;
10627  using Pythia8::PhaseSpace::limitTau;
10628  using Pythia8::PhaseSpace::limitY;
10629  using Pythia8::PhaseSpace::limitZ;
10630  using Pythia8::PhaseSpace::selectTau;
10631  using Pythia8::PhaseSpace::selectY;
10632  using Pythia8::PhaseSpace::selectZ;
10633  using Pythia8::PhaseSpace::select3Body;
10634  using Pythia8::PhaseSpace::solveSys;
10635  using Pythia8::PhaseSpace::useBW;
10636  using Pythia8::PhaseSpace::useNarrowBW;
10637  using Pythia8::PhaseSpace::idMass;
10638  using Pythia8::PhaseSpace::mPeak;
10639  using Pythia8::PhaseSpace::sPeak;
10640  using Pythia8::PhaseSpace::mWidth;
10641  using Pythia8::PhaseSpace::mMin;
10642  using Pythia8::PhaseSpace::mMax;
10643  using Pythia8::PhaseSpace::mw;
10644  using Pythia8::PhaseSpace::wmRat;
10645  using Pythia8::PhaseSpace::mLower;
10646  using Pythia8::PhaseSpace::mUpper;
10647  using Pythia8::PhaseSpace::sLower;
10648  using Pythia8::PhaseSpace::sUpper;
10649  using Pythia8::PhaseSpace::fracFlatS;
10650  using Pythia8::PhaseSpace::fracFlatM;
10651  using Pythia8::PhaseSpace::fracInv;
10652  using Pythia8::PhaseSpace::fracInv2;
10653  using Pythia8::PhaseSpace::atanLower;
10654  using Pythia8::PhaseSpace::atanUpper;
10655  using Pythia8::PhaseSpace::intBW;
10656  using Pythia8::PhaseSpace::intFlatS;
10657  using Pythia8::PhaseSpace::intFlatM;
10658  using Pythia8::PhaseSpace::intInv;
10659  using Pythia8::PhaseSpace::intInv2;
10660  using Pythia8::PhaseSpace::setupMass1;
10661  using Pythia8::PhaseSpace::setupMass2;
10662  using Pythia8::PhaseSpace::trialMass;
10663  using Pythia8::PhaseSpace::weightMass;
10664  using Pythia8::PhaseSpace::tRange;
10665  using Pythia8::PhaseSpace::tInRange;
10666 
10667 /* Internal director utilities */
10668 public:
10669  bool swig_get_inner(const char *swig_protected_method_name) const {
10670  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
10671  return (iv != swig_inner.end() ? iv->second : false);
10672  }
10673  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
10674  swig_inner[swig_protected_method_name] = swig_val;
10675  }
10676 private:
10677  mutable std::map<std::string, bool> swig_inner;
10678 
10679 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
10680 /* VTable implementation */
10681  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
10682  PyObject *method = vtable[method_index];
10683  if (!method) {
10684  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
10685  method = PyObject_GetAttr(swig_get_self(), name);
10686  if (!method) {
10687  std::string msg = "Method in class PhaseSpace doesn't exist, undefined ";
10688  msg += method_name;
10689  Swig::DirectorMethodException::raise(msg.c_str());
10690  }
10691  vtable[method_index] = method;
10692  }
10693  return method;
10694  }
10695 private:
10696  mutable swig::SwigVar_PyObject vtable[11];
10697 #endif
10698 
10699 };
10700 
10701 
10703 
10704 public:
10705  SwigDirector_SpaceShower(PyObject *self);
10706  virtual ~SwigDirector_SpaceShower();
10707  virtual void init(Pythia8::BeamParticle *arg0, Pythia8::BeamParticle *arg1);
10708  virtual bool limitPTmax(Pythia8::Event &arg0, double arg1 = 0., double arg2 = 0.);
10709  virtual void prepare(int arg0, Pythia8::Event &arg1, bool arg2 = true);
10710  virtual void update(int arg0, Pythia8::Event &arg1, bool arg2 = false);
10711  virtual double pTnext(Pythia8::Event &arg0, double arg1, double arg2, int arg3 = -1, bool arg4 = false);
10712  virtual bool branch(Pythia8::Event &arg0);
10713  virtual bool initUncertainties();
10714  virtual bool doRestart() const;
10715  virtual bool wasGamma2qqbar();
10716  virtual bool getHasWeaklyRadiated();
10717  virtual int system() const;
10718  virtual double enhancePTmax() const;
10719  virtual Pythia8::Event clustered(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
10720  virtual std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > getStateVariables(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
10721  virtual bool isSpacelike(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
10722  virtual std::vector< std::string,std::allocator< std::string > > getSplittingName(Pythia8::Event const &arg0, int arg1, int arg2, int arg3);
10723  virtual double getSplittingProb(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
10724  virtual bool allowedSplitting(Pythia8::Event const &arg0, int arg1, int arg2);
10725  virtual std::vector< int,std::allocator< int > > getRecoilers(Pythia8::Event const &arg0, int arg1, int arg2, std::string arg3);
10726  using Pythia8::SpaceShower::infoPtr;
10727  using Pythia8::SpaceShower::settingsPtr;
10728  using Pythia8::SpaceShower::particleDataPtr;
10729  using Pythia8::SpaceShower::rndmPtr;
10730  using Pythia8::SpaceShower::coupSMPtr;
10731  using Pythia8::SpaceShower::beamAPtr;
10732  using Pythia8::SpaceShower::beamBPtr;
10733  using Pythia8::SpaceShower::beamOffset;
10734  using Pythia8::SpaceShower::partonSystemsPtr;
10735  using Pythia8::SpaceShower::userHooksPtr;
10736  using Pythia8::SpaceShower::partonVertexPtr;
10737  using Pythia8::SpaceShower::doUncertainties;
10738  using Pythia8::SpaceShower::uVarMuSoftCorr;
10739  using Pythia8::SpaceShower::uVarMPIshowers;
10740  using Pythia8::SpaceShower::nUncertaintyVariations;
10741  using Pythia8::SpaceShower::nVarQCD;
10742  using Pythia8::SpaceShower::uVarNflavQ;
10743  using Pythia8::SpaceShower::dASmax;
10744  using Pythia8::SpaceShower::cNSpTmin;
10745  using Pythia8::SpaceShower::uVarpTmin2;
10746  using Pythia8::SpaceShower::overFactor;
10747  using Pythia8::SpaceShower::varG2GGmuRfac;
10748  using Pythia8::SpaceShower::varQ2QGmuRfac;
10749  using Pythia8::SpaceShower::varQ2GQmuRfac;
10750  using Pythia8::SpaceShower::varG2QQmuRfac;
10751  using Pythia8::SpaceShower::varX2XGmuRfac;
10752  using Pythia8::SpaceShower::varG2GGcNS;
10753  using Pythia8::SpaceShower::varQ2QGcNS;
10754  using Pythia8::SpaceShower::varQ2GQcNS;
10755  using Pythia8::SpaceShower::varG2QQcNS;
10756  using Pythia8::SpaceShower::varX2XGcNS;
10757  using Pythia8::SpaceShower::varPDFplus;
10758  using Pythia8::SpaceShower::varPDFminus;
10759  using Pythia8::SpaceShower::varPDFmember;
10760 
10761 /* Internal director utilities */
10762 public:
10763  bool swig_get_inner(const char *swig_protected_method_name) const {
10764  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
10765  return (iv != swig_inner.end() ? iv->second : false);
10766  }
10767  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
10768  swig_inner[swig_protected_method_name] = swig_val;
10769  }
10770 private:
10771  mutable std::map<std::string, bool> swig_inner;
10772 
10773 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
10774 /* VTable implementation */
10775  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
10776  PyObject *method = vtable[method_index];
10777  if (!method) {
10778  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
10779  method = PyObject_GetAttr(swig_get_self(), name);
10780  if (!method) {
10781  std::string msg = "Method in class SpaceShower doesn't exist, undefined ";
10782  msg += method_name;
10783  Swig::DirectorMethodException::raise(msg.c_str());
10784  }
10785  vtable[method_index] = method;
10786  }
10787  return method;
10788  }
10789 private:
10790  mutable swig::SwigVar_PyObject vtable[25];
10791 #endif
10792 
10793 };
10794 
10795 
10797 
10798 public:
10799  SwigDirector_TimeShower(PyObject *self);
10800  virtual ~SwigDirector_TimeShower();
10801  virtual void init(Pythia8::BeamParticle *arg0 = 0, Pythia8::BeamParticle *arg1 = 0);
10802  virtual bool limitPTmax(Pythia8::Event &arg0, double arg1 = 0., double arg2 = 0.);
10803  virtual int shower(int arg0, int arg1, Pythia8::Event &arg2, double arg3, int arg4 = 0);
10804  virtual int showerQED(int arg0, int arg1, Pythia8::Event &arg2, double arg3);
10805  virtual int showerQEDafterRemnants(Pythia8::Event &arg0);
10806  virtual void prepareGlobal(Pythia8::Event &arg0);
10807  virtual void prepare(int arg0, Pythia8::Event &arg1, bool arg2 = true);
10808  virtual void rescatterUpdate(int arg0, Pythia8::Event &arg1);
10809  virtual void update(int arg0, Pythia8::Event &arg1, bool arg2 = false);
10810  virtual double pTnext(Pythia8::Event &arg0, double arg1, double arg2, bool arg3 = false, bool arg4 = false);
10811  virtual bool branch(Pythia8::Event &arg0, bool arg1 = false);
10812  virtual bool initUncertainties();
10813  virtual bool getHasWeaklyRadiated();
10814  virtual int system() const;
10815  virtual double enhancePTmax();
10816  virtual double pTLastInShower();
10817  virtual Pythia8::Event clustered(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
10818  virtual std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > getStateVariables(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
10819  virtual bool isTimelike(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
10820  virtual std::vector< std::string,std::allocator< std::string > > getSplittingName(Pythia8::Event const &arg0, int arg1, int arg2, int arg3);
10821  virtual double getSplittingProb(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
10822  virtual bool allowedSplitting(Pythia8::Event const &arg0, int arg1, int arg2);
10823  virtual std::vector< int,std::allocator< int > > getRecoilers(Pythia8::Event const &arg0, int arg1, int arg2, std::string arg3);
10824  using Pythia8::TimeShower::infoPtr;
10825  using Pythia8::TimeShower::settingsPtr;
10826  using Pythia8::TimeShower::particleDataPtr;
10827  using Pythia8::TimeShower::rndmPtr;
10828  using Pythia8::TimeShower::coupSMPtr;
10829  using Pythia8::TimeShower::beamAPtr;
10830  using Pythia8::TimeShower::beamBPtr;
10831  using Pythia8::TimeShower::beamOffset;
10832  using Pythia8::TimeShower::partonSystemsPtr;
10833  using Pythia8::TimeShower::userHooksPtr;
10834  using Pythia8::TimeShower::partonVertexPtr;
10835  using Pythia8::TimeShower::doUncertainties;
10836  using Pythia8::TimeShower::uVarMuSoftCorr;
10837  using Pythia8::TimeShower::uVarMPIshowers;
10838  using Pythia8::TimeShower::noResVariations;
10839  using Pythia8::TimeShower::noProcVariations;
10840  using Pythia8::TimeShower::nUncertaintyVariations;
10841  using Pythia8::TimeShower::nVarQCD;
10842  using Pythia8::TimeShower::uVarNflavQ;
10843  using Pythia8::TimeShower::dASmax;
10844  using Pythia8::TimeShower::cNSpTmin;
10845  using Pythia8::TimeShower::uVarpTmin2;
10846  using Pythia8::TimeShower::overFactor;
10847  using Pythia8::TimeShower::varG2GGmuRfac;
10848  using Pythia8::TimeShower::varQ2QGmuRfac;
10849  using Pythia8::TimeShower::varG2QQmuRfac;
10850  using Pythia8::TimeShower::varX2XGmuRfac;
10851  using Pythia8::TimeShower::varG2GGcNS;
10852  using Pythia8::TimeShower::varQ2QGcNS;
10853  using Pythia8::TimeShower::varG2QQcNS;
10854  using Pythia8::TimeShower::varX2XGcNS;
10855  using Pythia8::TimeShower::varPDFplus;
10856  using Pythia8::TimeShower::varPDFminus;
10857  using Pythia8::TimeShower::varPDFmember;
10858 
10859 /* Internal director utilities */
10860 public:
10861  bool swig_get_inner(const char *swig_protected_method_name) const {
10862  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
10863  return (iv != swig_inner.end() ? iv->second : false);
10864  }
10865  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
10866  swig_inner[swig_protected_method_name] = swig_val;
10867  }
10868 private:
10869  mutable std::map<std::string, bool> swig_inner;
10870 
10871 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
10872 /* VTable implementation */
10873  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
10874  PyObject *method = vtable[method_index];
10875  if (!method) {
10876  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
10877  method = PyObject_GetAttr(swig_get_self(), name);
10878  if (!method) {
10879  std::string msg = "Method in class TimeShower doesn't exist, undefined ";
10880  msg += method_name;
10881  Swig::DirectorMethodException::raise(msg.c_str());
10882  }
10883  vtable[method_index] = method;
10884  }
10885  return method;
10886  }
10887 private:
10888  mutable swig::SwigVar_PyObject vtable[33];
10889 #endif
10890 
10891 };
10892 
10893 
10895 
10896 public:
10897  SwigDirector_DecayHandler(PyObject *self);
10898  virtual ~SwigDirector_DecayHandler();
10899  virtual bool decay(std::vector< int,std::allocator< int > > &arg0, std::vector< double,std::allocator< double > > &arg1, std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &arg2, int arg3, Pythia8::Event const &arg4);
10900  virtual bool chainDecay(std::vector< int,std::allocator< int > > &arg0, std::vector< int,std::allocator< int > > &arg1, std::vector< double,std::allocator< double > > &arg2, std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &arg3, int arg4, Pythia8::Event const &arg5);
10901 
10902 /* Internal director utilities */
10903 public:
10904  bool swig_get_inner(const char *swig_protected_method_name) const {
10905  std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
10906  return (iv != swig_inner.end() ? iv->second : false);
10907  }
10908  void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
10909  swig_inner[swig_protected_method_name] = swig_val;
10910  }
10911 private:
10912  mutable std::map<std::string, bool> swig_inner;
10913 
10914 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
10915 /* VTable implementation */
10916  PyObject *swig_get_method(size_t method_index, const char *method_name) const {
10917  PyObject *method = vtable[method_index];
10918  if (!method) {
10919  swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
10920  method = PyObject_GetAttr(swig_get_self(), name);
10921  if (!method) {
10922  std::string msg = "Method in class DecayHandler doesn't exist, undefined ";
10923  msg += method_name;
10924  Swig::DirectorMethodException::raise(msg.c_str());
10925  }
10926  vtable[method_index] = method;
10927  }
10928  return method;
10929  }
10930 private:
10931  mutable swig::SwigVar_PyObject vtable[2];
10932 #endif
10933 
10934 };
10935 
10936 
10937 #endif
10938 
10939 SwigDirector_RndmEngine::SwigDirector_RndmEngine(PyObject *self): Pythia8::RndmEngine(), Swig::Director(self) {
10940  SWIG_DIRECTOR_RGTR((Pythia8::RndmEngine *)this, this);
10941 }
10942 
10943 
10944 
10945 
10946 SwigDirector_RndmEngine::~SwigDirector_RndmEngine() {
10947 }
10948 
10949 double SwigDirector_RndmEngine::flat() {
10950  double c_result;
10951  if (!swig_get_self()) {
10952  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call RndmEngine.__init__.");
10953  }
10954 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
10955  const size_t swig_method_index = 0;
10956  const char * const swig_method_name = "flat";
10957  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
10958  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
10959 #else
10960  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "flat", NULL);
10961 #endif
10962  if (!result) {
10963  PyObject *error = PyErr_Occurred();
10964  if (error) {
10965  Swig::DirectorMethodException::raise("Error detected when calling 'RndmEngine.flat'");
10966  }
10967  }
10968  double swig_val;
10969  int swig_res = SWIG_AsVal_double(result, &swig_val);
10970  if (!SWIG_IsOK(swig_res)) {
10971  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
10972  }
10973  c_result = static_cast< double >(swig_val);
10974  return (double) c_result;
10975 }
10976 
10977 
10978 SwigDirector_BeamShape::SwigDirector_BeamShape(PyObject *self): Pythia8::BeamShape(), Swig::Director(self) {
10979  SWIG_DIRECTOR_RGTR((Pythia8::BeamShape *)this, this);
10980 }
10981 
10982 
10983 
10984 
10985 SwigDirector_BeamShape::~SwigDirector_BeamShape() {
10986 }
10987 
10988 void SwigDirector_BeamShape::init(Pythia8::Settings &settings, Pythia8::Rndm *rndmPtrIn) {
10990  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&settings), SWIGTYPE_p_Pythia8__Settings, 0 );
10992  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(rndmPtrIn), SWIGTYPE_p_Pythia8__Rndm, 0 );
10993  if (!swig_get_self()) {
10994  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BeamShape.__init__.");
10995  }
10996 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
10997  const size_t swig_method_index = 0;
10998  const char * const swig_method_name = "init";
10999  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11000  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
11001 #else
11002  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"init", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
11003 #endif
11004  if (!result) {
11005  PyObject *error = PyErr_Occurred();
11006  if (error) {
11007  Swig::DirectorMethodException::raise("Error detected when calling 'BeamShape.init'");
11008  }
11009  }
11010 }
11011 
11012 
11013 void SwigDirector_BeamShape::pick() {
11014  if (!swig_get_self()) {
11015  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BeamShape.__init__.");
11016  }
11017 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11018  const size_t swig_method_index = 1;
11019  const char * const swig_method_name = "pick";
11020  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11021  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
11022 #else
11023  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "pick", NULL);
11024 #endif
11025  if (!result) {
11026  PyObject *error = PyErr_Occurred();
11027  if (error) {
11028  Swig::DirectorMethodException::raise("Error detected when calling 'BeamShape.pick'");
11029  }
11030  }
11031 }
11032 
11033 
11034 SwigDirector_PDF::SwigDirector_PDF(PyObject *self, int idBeamIn): Pythia8::PDF(idBeamIn), Swig::Director(self) {
11035  SWIG_DIRECTOR_RGTR((Pythia8::PDF *)this, this);
11036 }
11037 
11038 
11039 
11040 
11041 SwigDirector_PDF::~SwigDirector_PDF() {
11042 }
11043 
11044 bool SwigDirector_PDF::isSetup() {
11045  bool c_result;
11046  if (!swig_get_self()) {
11047  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11048  }
11049 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11050  const size_t swig_method_index = 0;
11051  const char * const swig_method_name = "isSetup";
11052  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11053  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
11054 #else
11055  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isSetup", NULL);
11056 #endif
11057  if (!result) {
11058  PyObject *error = PyErr_Occurred();
11059  if (error) {
11060  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.isSetup'");
11061  }
11062  }
11063  bool swig_val;
11064  int swig_res = SWIG_AsVal_bool(result, &swig_val);
11065  if (!SWIG_IsOK(swig_res)) {
11066  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
11067  }
11068  c_result = static_cast< bool >(swig_val);
11069  return (bool) c_result;
11070 }
11071 
11072 
11073 void SwigDirector_PDF::newValenceContent(int idVal1In, int idVal2In) {
11075  obj0 = SWIG_From_int(static_cast< int >(idVal1In));
11077  obj1 = SWIG_From_int(static_cast< int >(idVal2In));
11078  if (!swig_get_self()) {
11079  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11080  }
11081 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11082  const size_t swig_method_index = 1;
11083  const char * const swig_method_name = "newValenceContent";
11084  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11085  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
11086 #else
11087  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"newValenceContent", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
11088 #endif
11089  if (!result) {
11090  PyObject *error = PyErr_Occurred();
11091  if (error) {
11092  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.newValenceContent'");
11093  }
11094  }
11095 }
11096 
11097 
11098 void SwigDirector_PDF::setExtrapolate(bool arg0) {
11100  obj0 = SWIG_From_bool(static_cast< bool >(arg0));
11101  if (!swig_get_self()) {
11102  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11103  }
11104 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11105  const size_t swig_method_index = 2;
11106  const char * const swig_method_name = "setExtrapolate";
11107  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11108  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
11109 #else
11110  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setExtrapolate", (char *)"(O)" ,(PyObject *)obj0);
11111 #endif
11112  if (!result) {
11113  PyObject *error = PyErr_Occurred();
11114  if (error) {
11115  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.setExtrapolate'");
11116  }
11117  }
11118 }
11119 
11120 
11121 double SwigDirector_PDF::xf(int id, double x, double Q2) {
11122  double c_result;
11124  obj0 = SWIG_From_int(static_cast< int >(id));
11126  obj1 = SWIG_From_double(static_cast< double >(x));
11128  obj2 = SWIG_From_double(static_cast< double >(Q2));
11129  if (!swig_get_self()) {
11130  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11131  }
11132 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11133  const size_t swig_method_index = 3;
11134  const char * const swig_method_name = "xf";
11135  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11136  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11137 #else
11138  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xf", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11139 #endif
11140  if (!result) {
11141  PyObject *error = PyErr_Occurred();
11142  if (error) {
11143  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xf'");
11144  }
11145  }
11146  double swig_val;
11147  int swig_res = SWIG_AsVal_double(result, &swig_val);
11148  if (!SWIG_IsOK(swig_res)) {
11149  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11150  }
11151  c_result = static_cast< double >(swig_val);
11152  return (double) c_result;
11153 }
11154 
11155 
11156 double SwigDirector_PDF::xfVal(int id, double x, double Q2) {
11157  double c_result;
11159  obj0 = SWIG_From_int(static_cast< int >(id));
11161  obj1 = SWIG_From_double(static_cast< double >(x));
11163  obj2 = SWIG_From_double(static_cast< double >(Q2));
11164  if (!swig_get_self()) {
11165  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11166  }
11167 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11168  const size_t swig_method_index = 4;
11169  const char * const swig_method_name = "xfVal";
11170  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11171  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11172 #else
11173  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfVal", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11174 #endif
11175  if (!result) {
11176  PyObject *error = PyErr_Occurred();
11177  if (error) {
11178  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfVal'");
11179  }
11180  }
11181  double swig_val;
11182  int swig_res = SWIG_AsVal_double(result, &swig_val);
11183  if (!SWIG_IsOK(swig_res)) {
11184  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11185  }
11186  c_result = static_cast< double >(swig_val);
11187  return (double) c_result;
11188 }
11189 
11190 
11191 double SwigDirector_PDF::xfSea(int id, double x, double Q2) {
11192  double c_result;
11194  obj0 = SWIG_From_int(static_cast< int >(id));
11196  obj1 = SWIG_From_double(static_cast< double >(x));
11198  obj2 = SWIG_From_double(static_cast< double >(Q2));
11199  if (!swig_get_self()) {
11200  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11201  }
11202 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11203  const size_t swig_method_index = 5;
11204  const char * const swig_method_name = "xfSea";
11205  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11206  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11207 #else
11208  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfSea", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11209 #endif
11210  if (!result) {
11211  PyObject *error = PyErr_Occurred();
11212  if (error) {
11213  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfSea'");
11214  }
11215  }
11216  double swig_val;
11217  int swig_res = SWIG_AsVal_double(result, &swig_val);
11218  if (!SWIG_IsOK(swig_res)) {
11219  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11220  }
11221  c_result = static_cast< double >(swig_val);
11222  return (double) c_result;
11223 }
11224 
11225 
11226 bool SwigDirector_PDF::insideBounds(double arg0, double arg1) {
11227  bool c_result;
11229  obj0 = SWIG_From_double(static_cast< double >(arg0));
11231  obj1 = SWIG_From_double(static_cast< double >(arg1));
11232  if (!swig_get_self()) {
11233  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11234  }
11235 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11236  const size_t swig_method_index = 6;
11237  const char * const swig_method_name = "insideBounds";
11238  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11239  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
11240 #else
11241  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"insideBounds", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
11242 #endif
11243  if (!result) {
11244  PyObject *error = PyErr_Occurred();
11245  if (error) {
11246  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.insideBounds'");
11247  }
11248  }
11249  bool swig_val;
11250  int swig_res = SWIG_AsVal_bool(result, &swig_val);
11251  if (!SWIG_IsOK(swig_res)) {
11252  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
11253  }
11254  c_result = static_cast< bool >(swig_val);
11255  return (bool) c_result;
11256 }
11257 
11258 
11259 double SwigDirector_PDF::alphaS(double arg0) {
11260  double c_result;
11262  obj0 = SWIG_From_double(static_cast< double >(arg0));
11263  if (!swig_get_self()) {
11264  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11265  }
11266 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11267  const size_t swig_method_index = 7;
11268  const char * const swig_method_name = "alphaS";
11269  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11270  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
11271 #else
11272  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"alphaS", (char *)"(O)" ,(PyObject *)obj0);
11273 #endif
11274  if (!result) {
11275  PyObject *error = PyErr_Occurred();
11276  if (error) {
11277  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.alphaS'");
11278  }
11279  }
11280  double swig_val;
11281  int swig_res = SWIG_AsVal_double(result, &swig_val);
11282  if (!SWIG_IsOK(swig_res)) {
11283  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11284  }
11285  c_result = static_cast< double >(swig_val);
11286  return (double) c_result;
11287 }
11288 
11289 
11290 double SwigDirector_PDF::mQuarkPDF(int arg0) {
11291  double c_result;
11293  obj0 = SWIG_From_int(static_cast< int >(arg0));
11294  if (!swig_get_self()) {
11295  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11296  }
11297 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11298  const size_t swig_method_index = 8;
11299  const char * const swig_method_name = "mQuarkPDF";
11300  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11301  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
11302 #else
11303  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"mQuarkPDF", (char *)"(O)" ,(PyObject *)obj0);
11304 #endif
11305  if (!result) {
11306  PyObject *error = PyErr_Occurred();
11307  if (error) {
11308  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.mQuarkPDF'");
11309  }
11310  }
11311  double swig_val;
11312  int swig_res = SWIG_AsVal_double(result, &swig_val);
11313  if (!SWIG_IsOK(swig_res)) {
11314  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11315  }
11316  c_result = static_cast< double >(swig_val);
11317  return (double) c_result;
11318 }
11319 
11320 
11321 int SwigDirector_PDF::nMembers() {
11322  int c_result;
11323  if (!swig_get_self()) {
11324  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11325  }
11326 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11327  const size_t swig_method_index = 9;
11328  const char * const swig_method_name = "nMembers";
11329  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11330  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
11331 #else
11332  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "nMembers", NULL);
11333 #endif
11334  if (!result) {
11335  PyObject *error = PyErr_Occurred();
11336  if (error) {
11337  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.nMembers'");
11338  }
11339  }
11340  int swig_val;
11341  int swig_res = SWIG_AsVal_int(result, &swig_val);
11342  if (!SWIG_IsOK(swig_res)) {
11343  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
11344  }
11345  c_result = static_cast< int >(swig_val);
11346  return (int) c_result;
11347 }
11348 
11349 
11350 void SwigDirector_PDF::calcPDFEnvelope(int arg0, double arg1, double arg2, int arg3) {
11352  obj0 = SWIG_From_int(static_cast< int >(arg0));
11354  obj1 = SWIG_From_double(static_cast< double >(arg1));
11356  obj2 = SWIG_From_double(static_cast< double >(arg2));
11358  obj3 = SWIG_From_int(static_cast< int >(arg3));
11359  if (!swig_get_self()) {
11360  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11361  }
11362 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11363  const size_t swig_method_index = 10;
11364  const char * const swig_method_name = "calcPDFEnvelope";
11365  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11366  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
11367 #else
11368  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"calcPDFEnvelope", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
11369 #endif
11370  if (!result) {
11371  PyObject *error = PyErr_Occurred();
11372  if (error) {
11373  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.calcPDFEnvelope'");
11374  }
11375  }
11376 }
11377 
11378 
11379 void SwigDirector_PDF::calcPDFEnvelope(std::pair< int,int > arg0, std::pair< double,double > arg1, double arg2, int arg3) {
11381  obj0 = swig::from(static_cast< std::pair< int,int > >(arg0));
11383  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_std__pairT_double_double_t, 0 );
11385  obj2 = SWIG_From_double(static_cast< double >(arg2));
11387  obj3 = SWIG_From_int(static_cast< int >(arg3));
11388  if (!swig_get_self()) {
11389  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11390  }
11391 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11392  const size_t swig_method_index = 11;
11393  const char * const swig_method_name = "calcPDFEnvelope";
11394  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11395  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
11396 #else
11397  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"calcPDFEnvelope", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
11398 #endif
11399  if (!result) {
11400  PyObject *error = PyErr_Occurred();
11401  if (error) {
11402  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.calcPDFEnvelope'");
11403  }
11404  }
11405 }
11406 
11407 
11408 Pythia8::PDF::PDFEnvelope SwigDirector_PDF::getPDFEnvelope() {
11409  void *swig_argp ;
11410  int swig_res = 0 ;
11411 
11412  Pythia8::PDF::PDFEnvelope c_result;
11413  if (!swig_get_self()) {
11414  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11415  }
11416 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11417  const size_t swig_method_index = 12;
11418  const char * const swig_method_name = "getPDFEnvelope";
11419  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11420  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
11421 #else
11422  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getPDFEnvelope", NULL);
11423 #endif
11424  if (!result) {
11425  PyObject *error = PyErr_Occurred();
11426  if (error) {
11427  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.getPDFEnvelope'");
11428  }
11429  }
11430  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_Pythia8__PDF__PDFEnvelope, 0 | 0);
11431  if (!SWIG_IsOK(swig_res)) {
11432  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Pythia8::PDF::PDFEnvelope""'");
11433  }
11434  c_result = *(reinterpret_cast< Pythia8::PDF::PDFEnvelope * >(swig_argp));
11435  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< Pythia8::PDF::PDFEnvelope * >(swig_argp);
11436  return (Pythia8::PDF::PDFEnvelope) c_result;
11437 }
11438 
11439 
11440 double SwigDirector_PDF::gammaPDFxDependence(int arg0, double arg1) {
11441  double c_result;
11443  obj0 = SWIG_From_int(static_cast< int >(arg0));
11445  obj1 = SWIG_From_double(static_cast< double >(arg1));
11446  if (!swig_get_self()) {
11447  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11448  }
11449 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11450  const size_t swig_method_index = 13;
11451  const char * const swig_method_name = "gammaPDFxDependence";
11452  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11453  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
11454 #else
11455  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"gammaPDFxDependence", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
11456 #endif
11457  if (!result) {
11458  PyObject *error = PyErr_Occurred();
11459  if (error) {
11460  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.gammaPDFxDependence'");
11461  }
11462  }
11463  double swig_val;
11464  int swig_res = SWIG_AsVal_double(result, &swig_val);
11465  if (!SWIG_IsOK(swig_res)) {
11466  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11467  }
11468  c_result = static_cast< double >(swig_val);
11469  return (double) c_result;
11470 }
11471 
11472 
11473 double SwigDirector_PDF::gammaPDFRefScale(int arg0) {
11474  double c_result;
11476  obj0 = SWIG_From_int(static_cast< int >(arg0));
11477  if (!swig_get_self()) {
11478  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11479  }
11480 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11481  const size_t swig_method_index = 14;
11482  const char * const swig_method_name = "gammaPDFRefScale";
11483  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11484  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
11485 #else
11486  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"gammaPDFRefScale", (char *)"(O)" ,(PyObject *)obj0);
11487 #endif
11488  if (!result) {
11489  PyObject *error = PyErr_Occurred();
11490  if (error) {
11491  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.gammaPDFRefScale'");
11492  }
11493  }
11494  double swig_val;
11495  int swig_res = SWIG_AsVal_double(result, &swig_val);
11496  if (!SWIG_IsOK(swig_res)) {
11497  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11498  }
11499  c_result = static_cast< double >(swig_val);
11500  return (double) c_result;
11501 }
11502 
11503 
11504 int SwigDirector_PDF::sampleGammaValFlavor(double arg0) {
11505  int c_result;
11507  obj0 = SWIG_From_double(static_cast< double >(arg0));
11508  if (!swig_get_self()) {
11509  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11510  }
11511 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11512  const size_t swig_method_index = 15;
11513  const char * const swig_method_name = "sampleGammaValFlavor";
11514  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11515  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
11516 #else
11517  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"sampleGammaValFlavor", (char *)"(O)" ,(PyObject *)obj0);
11518 #endif
11519  if (!result) {
11520  PyObject *error = PyErr_Occurred();
11521  if (error) {
11522  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.sampleGammaValFlavor'");
11523  }
11524  }
11525  int swig_val;
11526  int swig_res = SWIG_AsVal_int(result, &swig_val);
11527  if (!SWIG_IsOK(swig_res)) {
11528  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
11529  }
11530  c_result = static_cast< int >(swig_val);
11531  return (int) c_result;
11532 }
11533 
11534 
11535 double SwigDirector_PDF::xfIntegratedTotal(double arg0) {
11536  double c_result;
11538  obj0 = SWIG_From_double(static_cast< double >(arg0));
11539  if (!swig_get_self()) {
11540  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11541  }
11542 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11543  const size_t swig_method_index = 16;
11544  const char * const swig_method_name = "xfIntegratedTotal";
11545  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11546  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
11547 #else
11548  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfIntegratedTotal", (char *)"(O)" ,(PyObject *)obj0);
11549 #endif
11550  if (!result) {
11551  PyObject *error = PyErr_Occurred();
11552  if (error) {
11553  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfIntegratedTotal'");
11554  }
11555  }
11556  double swig_val;
11557  int swig_res = SWIG_AsVal_double(result, &swig_val);
11558  if (!SWIG_IsOK(swig_res)) {
11559  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11560  }
11561  c_result = static_cast< double >(swig_val);
11562  return (double) c_result;
11563 }
11564 
11565 
11566 double SwigDirector_PDF::xGamma() {
11567  double c_result;
11568  if (!swig_get_self()) {
11569  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11570  }
11571 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11572  const size_t swig_method_index = 17;
11573  const char * const swig_method_name = "xGamma";
11574  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11575  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
11576 #else
11577  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "xGamma", NULL);
11578 #endif
11579  if (!result) {
11580  PyObject *error = PyErr_Occurred();
11581  if (error) {
11582  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xGamma'");
11583  }
11584  }
11585  double swig_val;
11586  int swig_res = SWIG_AsVal_double(result, &swig_val);
11587  if (!SWIG_IsOK(swig_res)) {
11588  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11589  }
11590  c_result = static_cast< double >(swig_val);
11591  return (double) c_result;
11592 }
11593 
11594 
11595 void SwigDirector_PDF::xPom(double arg0) {
11597  obj0 = SWIG_From_double(static_cast< double >(arg0));
11598  if (!swig_get_self()) {
11599  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11600  }
11601 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11602  const size_t swig_method_index = 18;
11603  const char * const swig_method_name = "xPom";
11604  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11605  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
11606 #else
11607  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xPom", (char *)"(O)" ,(PyObject *)obj0);
11608 #endif
11609  if (!result) {
11610  PyObject *error = PyErr_Occurred();
11611  if (error) {
11612  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xPom'");
11613  }
11614  }
11615 }
11616 
11617 
11618 double SwigDirector_PDF::xfFlux(int arg0, double arg1, double arg2) {
11619  double c_result;
11621  obj0 = SWIG_From_int(static_cast< int >(arg0));
11623  obj1 = SWIG_From_double(static_cast< double >(arg1));
11625  obj2 = SWIG_From_double(static_cast< double >(arg2));
11626  if (!swig_get_self()) {
11627  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11628  }
11629 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11630  const size_t swig_method_index = 20;
11631  const char * const swig_method_name = "xfFlux";
11632  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11633  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11634 #else
11635  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfFlux", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11636 #endif
11637  if (!result) {
11638  PyObject *error = PyErr_Occurred();
11639  if (error) {
11640  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfFlux'");
11641  }
11642  }
11643  double swig_val;
11644  int swig_res = SWIG_AsVal_double(result, &swig_val);
11645  if (!SWIG_IsOK(swig_res)) {
11646  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11647  }
11648  c_result = static_cast< double >(swig_val);
11649  return (double) c_result;
11650 }
11651 
11652 
11653 double SwigDirector_PDF::xfApprox(int arg0, double arg1, double arg2) {
11654  double c_result;
11656  obj0 = SWIG_From_int(static_cast< int >(arg0));
11658  obj1 = SWIG_From_double(static_cast< double >(arg1));
11660  obj2 = SWIG_From_double(static_cast< double >(arg2));
11661  if (!swig_get_self()) {
11662  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11663  }
11664 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11665  const size_t swig_method_index = 21;
11666  const char * const swig_method_name = "xfApprox";
11667  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11668  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11669 #else
11670  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfApprox", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11671 #endif
11672  if (!result) {
11673  PyObject *error = PyErr_Occurred();
11674  if (error) {
11675  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfApprox'");
11676  }
11677  }
11678  double swig_val;
11679  int swig_res = SWIG_AsVal_double(result, &swig_val);
11680  if (!SWIG_IsOK(swig_res)) {
11681  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11682  }
11683  c_result = static_cast< double >(swig_val);
11684  return (double) c_result;
11685 }
11686 
11687 
11688 double SwigDirector_PDF::xfGamma(int arg0, double arg1, double arg2) {
11689  double c_result;
11691  obj0 = SWIG_From_int(static_cast< int >(arg0));
11693  obj1 = SWIG_From_double(static_cast< double >(arg1));
11695  obj2 = SWIG_From_double(static_cast< double >(arg2));
11696  if (!swig_get_self()) {
11697  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11698  }
11699 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11700  const size_t swig_method_index = 22;
11701  const char * const swig_method_name = "xfGamma";
11702  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11703  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11704 #else
11705  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfGamma", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11706 #endif
11707  if (!result) {
11708  PyObject *error = PyErr_Occurred();
11709  if (error) {
11710  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfGamma'");
11711  }
11712  }
11713  double swig_val;
11714  int swig_res = SWIG_AsVal_double(result, &swig_val);
11715  if (!SWIG_IsOK(swig_res)) {
11716  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11717  }
11718  c_result = static_cast< double >(swig_val);
11719  return (double) c_result;
11720 }
11721 
11722 
11723 double SwigDirector_PDF::intFluxApprox() {
11724  double c_result;
11725  if (!swig_get_self()) {
11726  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11727  }
11728 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11729  const size_t swig_method_index = 23;
11730  const char * const swig_method_name = "intFluxApprox";
11731  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11732  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
11733 #else
11734  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "intFluxApprox", NULL);
11735 #endif
11736  if (!result) {
11737  PyObject *error = PyErr_Occurred();
11738  if (error) {
11739  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.intFluxApprox'");
11740  }
11741  }
11742  double swig_val;
11743  int swig_res = SWIG_AsVal_double(result, &swig_val);
11744  if (!SWIG_IsOK(swig_res)) {
11745  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11746  }
11747  c_result = static_cast< double >(swig_val);
11748  return (double) c_result;
11749 }
11750 
11751 
11752 double SwigDirector_PDF::getXmin() {
11753  double c_result;
11754  if (!swig_get_self()) {
11755  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11756  }
11757 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11758  const size_t swig_method_index = 24;
11759  const char * const swig_method_name = "getXmin";
11760  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11761  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
11762 #else
11763  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getXmin", NULL);
11764 #endif
11765  if (!result) {
11766  PyObject *error = PyErr_Occurred();
11767  if (error) {
11768  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.getXmin'");
11769  }
11770  }
11771  double swig_val;
11772  int swig_res = SWIG_AsVal_double(result, &swig_val);
11773  if (!SWIG_IsOK(swig_res)) {
11774  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11775  }
11776  c_result = static_cast< double >(swig_val);
11777  return (double) c_result;
11778 }
11779 
11780 
11781 double SwigDirector_PDF::getXhadr() {
11782  double c_result;
11783  if (!swig_get_self()) {
11784  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11785  }
11786 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11787  const size_t swig_method_index = 25;
11788  const char * const swig_method_name = "getXhadr";
11789  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11790  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
11791 #else
11792  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getXhadr", NULL);
11793 #endif
11794  if (!result) {
11795  PyObject *error = PyErr_Occurred();
11796  if (error) {
11797  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.getXhadr'");
11798  }
11799  }
11800  double swig_val;
11801  int swig_res = SWIG_AsVal_double(result, &swig_val);
11802  if (!SWIG_IsOK(swig_res)) {
11803  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11804  }
11805  c_result = static_cast< double >(swig_val);
11806  return (double) c_result;
11807 }
11808 
11809 
11810 double SwigDirector_PDF::sampleXgamma(double arg0) {
11811  double c_result;
11813  obj0 = SWIG_From_double(static_cast< double >(arg0));
11814  if (!swig_get_self()) {
11815  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11816  }
11817 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11818  const size_t swig_method_index = 26;
11819  const char * const swig_method_name = "sampleXgamma";
11820  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11821  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
11822 #else
11823  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"sampleXgamma", (char *)"(O)" ,(PyObject *)obj0);
11824 #endif
11825  if (!result) {
11826  PyObject *error = PyErr_Occurred();
11827  if (error) {
11828  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.sampleXgamma'");
11829  }
11830  }
11831  double swig_val;
11832  int swig_res = SWIG_AsVal_double(result, &swig_val);
11833  if (!SWIG_IsOK(swig_res)) {
11834  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11835  }
11836  c_result = static_cast< double >(swig_val);
11837  return (double) c_result;
11838 }
11839 
11840 
11841 double SwigDirector_PDF::sampleQ2gamma(double arg0) {
11842  double c_result;
11844  obj0 = SWIG_From_double(static_cast< double >(arg0));
11845  if (!swig_get_self()) {
11846  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11847  }
11848 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11849  const size_t swig_method_index = 27;
11850  const char * const swig_method_name = "sampleQ2gamma";
11851  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11852  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
11853 #else
11854  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"sampleQ2gamma", (char *)"(O)" ,(PyObject *)obj0);
11855 #endif
11856  if (!result) {
11857  PyObject *error = PyErr_Occurred();
11858  if (error) {
11859  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.sampleQ2gamma'");
11860  }
11861  }
11862  double swig_val;
11863  int swig_res = SWIG_AsVal_double(result, &swig_val);
11864  if (!SWIG_IsOK(swig_res)) {
11865  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11866  }
11867  c_result = static_cast< double >(swig_val);
11868  return (double) c_result;
11869 }
11870 
11871 
11872 double SwigDirector_PDF::xfMax(int id, double x, double Q2) {
11873  double c_result;
11875  obj0 = SWIG_From_int(static_cast< int >(id));
11877  obj1 = SWIG_From_double(static_cast< double >(x));
11879  obj2 = SWIG_From_double(static_cast< double >(Q2));
11880  if (!swig_get_self()) {
11881  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11882  }
11883 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11884  const size_t swig_method_index = 28;
11885  const char * const swig_method_name = "xfMax";
11886  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11887  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11888 #else
11889  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfMax", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11890 #endif
11891  if (!result) {
11892  PyObject *error = PyErr_Occurred();
11893  if (error) {
11894  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfMax'");
11895  }
11896  }
11897  double swig_val;
11898  int swig_res = SWIG_AsVal_double(result, &swig_val);
11899  if (!SWIG_IsOK(swig_res)) {
11900  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11901  }
11902  c_result = static_cast< double >(swig_val);
11903  return (double) c_result;
11904 }
11905 
11906 
11907 double SwigDirector_PDF::xfSame(int id, double x, double Q2) {
11908  double c_result;
11910  obj0 = SWIG_From_int(static_cast< int >(id));
11912  obj1 = SWIG_From_double(static_cast< double >(x));
11914  obj2 = SWIG_From_double(static_cast< double >(Q2));
11915  if (!swig_get_self()) {
11916  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11917  }
11918 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11919  const size_t swig_method_index = 29;
11920  const char * const swig_method_name = "xfSame";
11921  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11922  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11923 #else
11924  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfSame", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11925 #endif
11926  if (!result) {
11927  PyObject *error = PyErr_Occurred();
11928  if (error) {
11929  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfSame'");
11930  }
11931  }
11932  double swig_val;
11933  int swig_res = SWIG_AsVal_double(result, &swig_val);
11934  if (!SWIG_IsOK(swig_res)) {
11935  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
11936  }
11937  c_result = static_cast< double >(swig_val);
11938  return (double) c_result;
11939 }
11940 
11941 
11942 void SwigDirector_PDF::setVMDscale(double arg0) {
11944  obj0 = SWIG_From_double(static_cast< double >(arg0));
11945  if (!swig_get_self()) {
11946  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11947  }
11948 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11949  const size_t swig_method_index = 30;
11950  const char * const swig_method_name = "setVMDscale";
11951  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11952  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
11953 #else
11954  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setVMDscale", (char *)"(O)" ,(PyObject *)obj0);
11955 #endif
11956  if (!result) {
11957  PyObject *error = PyErr_Occurred();
11958  if (error) {
11959  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.setVMDscale'");
11960  }
11961  }
11962 }
11963 
11964 
11965 void SwigDirector_PDF::xfUpdate(int id, double x, double Q2) {
11967  obj0 = SWIG_From_int(static_cast< int >(id));
11969  obj1 = SWIG_From_double(static_cast< double >(x));
11971  obj2 = SWIG_From_double(static_cast< double >(Q2));
11972  swig_set_inner("xfUpdate", true);
11973  if (!swig_get_self()) {
11974  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
11975  }
11976 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
11977  const size_t swig_method_index = 32;
11978  const char * const swig_method_name = "xfUpdate";
11979  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
11980  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11981 #else
11982  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfUpdate", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
11983 #endif
11984  swig_set_inner("xfUpdate", false);
11985  if (!result) {
11986  PyObject *error = PyErr_Occurred();
11987  if (error) {
11988  Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfUpdate'");
11989  }
11990  }
11991 }
11992 
11993 
11994 SwigDirector_ResonanceWidths::SwigDirector_ResonanceWidths(PyObject *self): Pythia8::ResonanceWidths(), Swig::Director(self) {
11995  SWIG_DIRECTOR_RGTR((Pythia8::ResonanceWidths *)this, this);
11996 }
11997 
11998 
11999 
12000 
12001 SwigDirector_ResonanceWidths::~SwigDirector_ResonanceWidths() {
12002 }
12003 
12004 bool SwigDirector_ResonanceWidths::init(Pythia8::Info *infoPtrIn, Pythia8::Settings *settingsPtrIn, Pythia8::ParticleData *particleDataPtrIn, Pythia8::Couplings *couplingsPtrIn) {
12005  bool c_result;
12007  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(infoPtrIn), SWIGTYPE_p_Pythia8__Info, 0 );
12009  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(settingsPtrIn), SWIGTYPE_p_Pythia8__Settings, 0 );
12011  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(particleDataPtrIn), SWIGTYPE_p_Pythia8__ParticleData, 0 );
12013  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(couplingsPtrIn), SWIGTYPE_p_Pythia8__Couplings, 0 );
12014  if (!swig_get_self()) {
12015  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
12016  }
12017 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12018  const size_t swig_method_index = 0;
12019  const char * const swig_method_name = "init";
12020  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12021  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
12022 #else
12023  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"init", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
12024 #endif
12025  if (!result) {
12026  PyObject *error = PyErr_Occurred();
12027  if (error) {
12028  Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.init'");
12029  }
12030  }
12031  bool swig_val;
12032  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12033  if (!SWIG_IsOK(swig_res)) {
12034  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12035  }
12036  c_result = static_cast< bool >(swig_val);
12037  return (bool) c_result;
12038 }
12039 
12040 
12041 void SwigDirector_ResonanceWidths::initConstants() {
12042  swig_set_inner("initConstants", true);
12043  if (!swig_get_self()) {
12044  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
12045  }
12046 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12047  const size_t swig_method_index = 1;
12048  const char * const swig_method_name = "initConstants";
12049  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12050  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12051 #else
12052  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initConstants", NULL);
12053 #endif
12054  swig_set_inner("initConstants", false);
12055  if (!result) {
12056  PyObject *error = PyErr_Occurred();
12057  if (error) {
12058  Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.initConstants'");
12059  }
12060  }
12061 }
12062 
12063 
12064 bool SwigDirector_ResonanceWidths::initBSM() {
12065  bool c_result;
12066  swig_set_inner("initBSM", true);
12067  if (!swig_get_self()) {
12068  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
12069  }
12070 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12071  const size_t swig_method_index = 2;
12072  const char * const swig_method_name = "initBSM";
12073  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12074  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12075 #else
12076  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initBSM", NULL);
12077 #endif
12078  swig_set_inner("initBSM", false);
12079  if (!result) {
12080  PyObject *error = PyErr_Occurred();
12081  if (error) {
12082  Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.initBSM'");
12083  }
12084  }
12085  bool swig_val;
12086  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12087  if (!SWIG_IsOK(swig_res)) {
12088  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12089  }
12090  c_result = static_cast< bool >(swig_val);
12091  return (bool) c_result;
12092 }
12093 
12094 
12095 bool SwigDirector_ResonanceWidths::allowCalc() {
12096  bool c_result;
12097  swig_set_inner("allowCalc", true);
12098  if (!swig_get_self()) {
12099  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
12100  }
12101 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12102  const size_t swig_method_index = 3;
12103  const char * const swig_method_name = "allowCalc";
12104  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12105  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12106 #else
12107  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "allowCalc", NULL);
12108 #endif
12109  swig_set_inner("allowCalc", false);
12110  if (!result) {
12111  PyObject *error = PyErr_Occurred();
12112  if (error) {
12113  Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.allowCalc'");
12114  }
12115  }
12116  bool swig_val;
12117  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12118  if (!SWIG_IsOK(swig_res)) {
12119  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12120  }
12121  c_result = static_cast< bool >(swig_val);
12122  return (bool) c_result;
12123 }
12124 
12125 
12126 void SwigDirector_ResonanceWidths::calcPreFac(bool arg0) {
12128  obj0 = SWIG_From_bool(static_cast< bool >(arg0));
12129  swig_set_inner("calcPreFac", true);
12130  if (!swig_get_self()) {
12131  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
12132  }
12133 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12134  const size_t swig_method_index = 4;
12135  const char * const swig_method_name = "calcPreFac";
12136  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12137  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12138 #else
12139  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"calcPreFac", (char *)"(O)" ,(PyObject *)obj0);
12140 #endif
12141  swig_set_inner("calcPreFac", false);
12142  if (!result) {
12143  PyObject *error = PyErr_Occurred();
12144  if (error) {
12145  Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.calcPreFac'");
12146  }
12147  }
12148 }
12149 
12150 
12151 void SwigDirector_ResonanceWidths::calcWidth(bool arg0) {
12153  obj0 = SWIG_From_bool(static_cast< bool >(arg0));
12154  swig_set_inner("calcWidth", true);
12155  if (!swig_get_self()) {
12156  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
12157  }
12158 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12159  const size_t swig_method_index = 6;
12160  const char * const swig_method_name = "calcWidth";
12161  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12162  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12163 #else
12164  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"calcWidth", (char *)"(O)" ,(PyObject *)obj0);
12165 #endif
12166  swig_set_inner("calcWidth", false);
12167  if (!result) {
12168  PyObject *error = PyErr_Occurred();
12169  if (error) {
12170  Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.calcWidth'");
12171  }
12172  }
12173 }
12174 
12175 
12176 SwigDirector_LHAup::SwigDirector_LHAup(PyObject *self, int strategyIn): Pythia8::LHAup(strategyIn), Swig::Director(self) {
12177  SWIG_DIRECTOR_RGTR((Pythia8::LHAup *)this, this);
12178 }
12179 
12180 
12181 
12182 
12183 SwigDirector_LHAup::~SwigDirector_LHAup() {
12184 }
12185 
12186 void SwigDirector_LHAup::newEventFile(char const *arg0) {
12188  obj0 = SWIG_FromCharPtr((const char *)arg0);
12189  if (!swig_get_self()) {
12190  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
12191  }
12192 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12193  const size_t swig_method_index = 0;
12194  const char * const swig_method_name = "newEventFile";
12195  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12196  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12197 #else
12198  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"newEventFile", (char *)"(O)" ,(PyObject *)obj0);
12199 #endif
12200  if (!result) {
12201  PyObject *error = PyErr_Occurred();
12202  if (error) {
12203  Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.newEventFile'");
12204  }
12205  }
12206 }
12207 
12208 
12209 bool SwigDirector_LHAup::fileFound() {
12210  bool c_result;
12211  if (!swig_get_self()) {
12212  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
12213  }
12214 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12215  const size_t swig_method_index = 1;
12216  const char * const swig_method_name = "fileFound";
12217  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12218  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12219 #else
12220  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "fileFound", NULL);
12221 #endif
12222  if (!result) {
12223  PyObject *error = PyErr_Occurred();
12224  if (error) {
12225  Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.fileFound'");
12226  }
12227  }
12228  bool swig_val;
12229  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12230  if (!SWIG_IsOK(swig_res)) {
12231  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12232  }
12233  c_result = static_cast< bool >(swig_val);
12234  return (bool) c_result;
12235 }
12236 
12237 
12238 bool SwigDirector_LHAup::useExternal() {
12239  bool c_result;
12240  if (!swig_get_self()) {
12241  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
12242  }
12243 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12244  const size_t swig_method_index = 2;
12245  const char * const swig_method_name = "useExternal";
12246  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12247  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12248 #else
12249  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "useExternal", NULL);
12250 #endif
12251  if (!result) {
12252  PyObject *error = PyErr_Occurred();
12253  if (error) {
12254  Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.useExternal'");
12255  }
12256  }
12257  bool swig_val;
12258  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12259  if (!SWIG_IsOK(swig_res)) {
12260  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12261  }
12262  c_result = static_cast< bool >(swig_val);
12263  return (bool) c_result;
12264 }
12265 
12266 
12267 bool SwigDirector_LHAup::setInit() {
12268  bool c_result;
12269  if (!swig_get_self()) {
12270  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
12271  }
12272 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12273  const size_t swig_method_index = 3;
12274  const char * const swig_method_name = "setInit";
12275  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12276  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12277 #else
12278  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "setInit", NULL);
12279 #endif
12280  if (!result) {
12281  PyObject *error = PyErr_Occurred();
12282  if (error) {
12283  Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.setInit'");
12284  }
12285  }
12286  bool swig_val;
12287  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12288  if (!SWIG_IsOK(swig_res)) {
12289  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12290  }
12291  c_result = static_cast< bool >(swig_val);
12292  return (bool) c_result;
12293 }
12294 
12295 
12296 bool SwigDirector_LHAup::setEvent(int idProcIn) {
12297  bool c_result;
12299  obj0 = SWIG_From_int(static_cast< int >(idProcIn));
12300  if (!swig_get_self()) {
12301  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
12302  }
12303 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12304  const size_t swig_method_index = 4;
12305  const char * const swig_method_name = "setEvent";
12306  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12307  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12308 #else
12309  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setEvent", (char *)"(O)" ,(PyObject *)obj0);
12310 #endif
12311  if (!result) {
12312  PyObject *error = PyErr_Occurred();
12313  if (error) {
12314  Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.setEvent'");
12315  }
12316  }
12317  bool swig_val;
12318  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12319  if (!SWIG_IsOK(swig_res)) {
12320  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12321  }
12322  c_result = static_cast< bool >(swig_val);
12323  return (bool) c_result;
12324 }
12325 
12326 
12327 bool SwigDirector_LHAup::skipEvent(int nSkip) {
12328  bool c_result;
12330  obj0 = SWIG_From_int(static_cast< int >(nSkip));
12331  if (!swig_get_self()) {
12332  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
12333  }
12334 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12335  const size_t swig_method_index = 6;
12336  const char * const swig_method_name = "skipEvent";
12337  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12338  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12339 #else
12340  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"skipEvent", (char *)"(O)" ,(PyObject *)obj0);
12341 #endif
12342  if (!result) {
12343  PyObject *error = PyErr_Occurred();
12344  if (error) {
12345  Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.skipEvent'");
12346  }
12347  }
12348  bool swig_val;
12349  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12350  if (!SWIG_IsOK(swig_res)) {
12351  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12352  }
12353  c_result = static_cast< bool >(swig_val);
12354  return (bool) c_result;
12355 }
12356 
12357 
12358 bool SwigDirector_LHAup::openLHEF(std::string fileNameIn) {
12359  bool c_result;
12361  obj0 = SWIG_From_std_string(static_cast< std::string >(fileNameIn));
12362  if (!swig_get_self()) {
12363  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
12364  }
12365 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12366  const size_t swig_method_index = 7;
12367  const char * const swig_method_name = "openLHEF";
12368  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12369  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12370 #else
12371  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"openLHEF", (char *)"(O)" ,(PyObject *)obj0);
12372 #endif
12373  if (!result) {
12374  PyObject *error = PyErr_Occurred();
12375  if (error) {
12376  Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.openLHEF'");
12377  }
12378  }
12379  bool swig_val;
12380  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12381  if (!SWIG_IsOK(swig_res)) {
12382  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12383  }
12384  c_result = static_cast< bool >(swig_val);
12385  return (bool) c_result;
12386 }
12387 
12388 
12389 bool SwigDirector_LHAup::closeLHEF(bool updateInit) {
12390  bool c_result;
12392  obj0 = SWIG_From_bool(static_cast< bool >(updateInit));
12393  if (!swig_get_self()) {
12394  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
12395  }
12396 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12397  const size_t swig_method_index = 8;
12398  const char * const swig_method_name = "closeLHEF";
12399  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12400  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12401 #else
12402  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"closeLHEF", (char *)"(O)" ,(PyObject *)obj0);
12403 #endif
12404  if (!result) {
12405  PyObject *error = PyErr_Occurred();
12406  if (error) {
12407  Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.closeLHEF'");
12408  }
12409  }
12410  bool swig_val;
12411  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12412  if (!SWIG_IsOK(swig_res)) {
12413  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12414  }
12415  c_result = static_cast< bool >(swig_val);
12416  return (bool) c_result;
12417 }
12418 
12419 
12420 SwigDirector_MergingHooks::SwigDirector_MergingHooks(PyObject *self): Pythia8::MergingHooks(), Swig::Director(self) {
12421  SWIG_DIRECTOR_RGTR((Pythia8::MergingHooks *)this, this);
12422 }
12423 
12424 
12425 
12426 
12427 SwigDirector_MergingHooks::~SwigDirector_MergingHooks() {
12428 }
12429 
12430 double SwigDirector_MergingHooks::tmsDefinition(Pythia8::Event const &event) {
12431  double c_result;
12433  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event, 0 );
12434  if (!swig_get_self()) {
12435  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12436  }
12437 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12438  const size_t swig_method_index = 0;
12439  const char * const swig_method_name = "tmsDefinition";
12440  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12441  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12442 #else
12443  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"tmsDefinition", (char *)"(O)" ,(PyObject *)obj0);
12444 #endif
12445  if (!result) {
12446  PyObject *error = PyErr_Occurred();
12447  if (error) {
12448  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.tmsDefinition'");
12449  }
12450  }
12451  double swig_val;
12452  int swig_res = SWIG_AsVal_double(result, &swig_val);
12453  if (!SWIG_IsOK(swig_res)) {
12454  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
12455  }
12456  c_result = static_cast< double >(swig_val);
12457  return (double) c_result;
12458 }
12459 
12460 
12461 double SwigDirector_MergingHooks::dampenIfFailCuts(Pythia8::Event const &inEvent) {
12462  double c_result;
12464  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inEvent), SWIGTYPE_p_Pythia8__Event, 0 );
12465  if (!swig_get_self()) {
12466  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12467  }
12468 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12469  const size_t swig_method_index = 1;
12470  const char * const swig_method_name = "dampenIfFailCuts";
12471  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12472  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12473 #else
12474  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"dampenIfFailCuts", (char *)"(O)" ,(PyObject *)obj0);
12475 #endif
12476  if (!result) {
12477  PyObject *error = PyErr_Occurred();
12478  if (error) {
12479  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.dampenIfFailCuts'");
12480  }
12481  }
12482  double swig_val;
12483  int swig_res = SWIG_AsVal_double(result, &swig_val);
12484  if (!SWIG_IsOK(swig_res)) {
12485  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
12486  }
12487  c_result = static_cast< double >(swig_val);
12488  return (double) c_result;
12489 }
12490 
12491 
12492 bool SwigDirector_MergingHooks::canCutOnRecState() {
12493  bool c_result;
12494  if (!swig_get_self()) {
12495  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12496  }
12497 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12498  const size_t swig_method_index = 2;
12499  const char * const swig_method_name = "canCutOnRecState";
12500  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12501  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12502 #else
12503  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canCutOnRecState", NULL);
12504 #endif
12505  if (!result) {
12506  PyObject *error = PyErr_Occurred();
12507  if (error) {
12508  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.canCutOnRecState'");
12509  }
12510  }
12511  bool swig_val;
12512  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12513  if (!SWIG_IsOK(swig_res)) {
12514  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12515  }
12516  c_result = static_cast< bool >(swig_val);
12517  return (bool) c_result;
12518 }
12519 
12520 
12521 bool SwigDirector_MergingHooks::doCutOnRecState(Pythia8::Event const &event) {
12522  bool c_result;
12524  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event, 0 );
12525  if (!swig_get_self()) {
12526  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12527  }
12528 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12529  const size_t swig_method_index = 3;
12530  const char * const swig_method_name = "doCutOnRecState";
12531  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12532  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12533 #else
12534  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doCutOnRecState", (char *)"(O)" ,(PyObject *)obj0);
12535 #endif
12536  if (!result) {
12537  PyObject *error = PyErr_Occurred();
12538  if (error) {
12539  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.doCutOnRecState'");
12540  }
12541  }
12542  bool swig_val;
12543  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12544  if (!SWIG_IsOK(swig_res)) {
12545  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12546  }
12547  c_result = static_cast< bool >(swig_val);
12548  return (bool) c_result;
12549 }
12550 
12551 
12552 bool SwigDirector_MergingHooks::canVetoTrialEmission() {
12553  bool c_result;
12554  if (!swig_get_self()) {
12555  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12556  }
12557 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12558  const size_t swig_method_index = 4;
12559  const char * const swig_method_name = "canVetoTrialEmission";
12560  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12561  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12562 #else
12563  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoTrialEmission", NULL);
12564 #endif
12565  if (!result) {
12566  PyObject *error = PyErr_Occurred();
12567  if (error) {
12568  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.canVetoTrialEmission'");
12569  }
12570  }
12571  bool swig_val;
12572  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12573  if (!SWIG_IsOK(swig_res)) {
12574  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12575  }
12576  c_result = static_cast< bool >(swig_val);
12577  return (bool) c_result;
12578 }
12579 
12580 
12581 bool SwigDirector_MergingHooks::doVetoTrialEmission(Pythia8::Event const &arg0, Pythia8::Event const &arg1) {
12582  bool c_result;
12584  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
12586  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
12587  if (!swig_get_self()) {
12588  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12589  }
12590 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12591  const size_t swig_method_index = 5;
12592  const char * const swig_method_name = "doVetoTrialEmission";
12593  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12594  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
12595 #else
12596  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoTrialEmission", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
12597 #endif
12598  if (!result) {
12599  PyObject *error = PyErr_Occurred();
12600  if (error) {
12601  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.doVetoTrialEmission'");
12602  }
12603  }
12604  bool swig_val;
12605  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12606  if (!SWIG_IsOK(swig_res)) {
12607  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12608  }
12609  c_result = static_cast< bool >(swig_val);
12610  return (bool) c_result;
12611 }
12612 
12613 
12614 double SwigDirector_MergingHooks::hardProcessME(Pythia8::Event const &inEvent) {
12615  double c_result;
12617  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inEvent), SWIGTYPE_p_Pythia8__Event, 0 );
12618  if (!swig_get_self()) {
12619  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12620  }
12621 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12622  const size_t swig_method_index = 6;
12623  const char * const swig_method_name = "hardProcessME";
12624  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12625  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12626 #else
12627  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"hardProcessME", (char *)"(O)" ,(PyObject *)obj0);
12628 #endif
12629  if (!result) {
12630  PyObject *error = PyErr_Occurred();
12631  if (error) {
12632  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.hardProcessME'");
12633  }
12634  }
12635  double swig_val;
12636  int swig_res = SWIG_AsVal_double(result, &swig_val);
12637  if (!SWIG_IsOK(swig_res)) {
12638  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
12639  }
12640  c_result = static_cast< double >(swig_val);
12641  return (double) c_result;
12642 }
12643 
12644 
12645 void SwigDirector_MergingHooks::init() {
12646  if (!swig_get_self()) {
12647  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12648  }
12649 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12650  const size_t swig_method_index = 7;
12651  const char * const swig_method_name = "init";
12652  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12653  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12654 #else
12655  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "init", NULL);
12656 #endif
12657  if (!result) {
12658  PyObject *error = PyErr_Occurred();
12659  if (error) {
12660  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.init'");
12661  }
12662  }
12663 }
12664 
12665 
12666 int SwigDirector_MergingHooks::getNumberOfClusteringSteps(Pythia8::Event const &event, bool resetNjetMax) {
12667  int c_result;
12669  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event, 0 );
12671  obj1 = SWIG_From_bool(static_cast< bool >(resetNjetMax));
12672  if (!swig_get_self()) {
12673  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12674  }
12675 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12676  const size_t swig_method_index = 8;
12677  const char * const swig_method_name = "getNumberOfClusteringSteps";
12678  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12679  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
12680 #else
12681  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getNumberOfClusteringSteps", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
12682 #endif
12683  if (!result) {
12684  PyObject *error = PyErr_Occurred();
12685  if (error) {
12686  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.getNumberOfClusteringSteps'");
12687  }
12688  }
12689  int swig_val;
12690  int swig_res = SWIG_AsVal_int(result, &swig_val);
12691  if (!SWIG_IsOK(swig_res)) {
12692  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
12693  }
12694  c_result = static_cast< int >(swig_val);
12695  return (int) c_result;
12696 }
12697 
12698 
12699 double SwigDirector_MergingHooks::tmsNow(Pythia8::Event const &event) {
12700  double c_result;
12702  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event, 0 );
12703  if (!swig_get_self()) {
12704  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12705  }
12706 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12707  const size_t swig_method_index = 10;
12708  const char * const swig_method_name = "tmsNow";
12709  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12710  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12711 #else
12712  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"tmsNow", (char *)"(O)" ,(PyObject *)obj0);
12713 #endif
12714  if (!result) {
12715  PyObject *error = PyErr_Occurred();
12716  if (error) {
12717  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.tmsNow'");
12718  }
12719  }
12720  double swig_val;
12721  int swig_res = SWIG_AsVal_double(result, &swig_val);
12722  if (!SWIG_IsOK(swig_res)) {
12723  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
12724  }
12725  c_result = static_cast< double >(swig_val);
12726  return (double) c_result;
12727 }
12728 
12729 
12730 bool SwigDirector_MergingHooks::canVetoEmission() {
12731  bool c_result;
12732  if (!swig_get_self()) {
12733  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12734  }
12735 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12736  const size_t swig_method_index = 11;
12737  const char * const swig_method_name = "canVetoEmission";
12738  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12739  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12740 #else
12741  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoEmission", NULL);
12742 #endif
12743  if (!result) {
12744  PyObject *error = PyErr_Occurred();
12745  if (error) {
12746  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.canVetoEmission'");
12747  }
12748  }
12749  bool swig_val;
12750  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12751  if (!SWIG_IsOK(swig_res)) {
12752  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12753  }
12754  c_result = static_cast< bool >(swig_val);
12755  return (bool) c_result;
12756 }
12757 
12758 
12759 bool SwigDirector_MergingHooks::doVetoEmission(Pythia8::Event const &arg0) {
12760  bool c_result;
12762  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
12763  if (!swig_get_self()) {
12764  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12765  }
12766 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12767  const size_t swig_method_index = 12;
12768  const char * const swig_method_name = "doVetoEmission";
12769  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12770  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
12771 #else
12772  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoEmission", (char *)"(O)" ,(PyObject *)obj0);
12773 #endif
12774  if (!result) {
12775  PyObject *error = PyErr_Occurred();
12776  if (error) {
12777  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.doVetoEmission'");
12778  }
12779  }
12780  bool swig_val;
12781  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12782  if (!SWIG_IsOK(swig_res)) {
12783  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12784  }
12785  c_result = static_cast< bool >(swig_val);
12786  return (bool) c_result;
12787 }
12788 
12789 
12790 bool SwigDirector_MergingHooks::useShowerPlugin() {
12791  bool c_result;
12792  if (!swig_get_self()) {
12793  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12794  }
12795 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12796  const size_t swig_method_index = 13;
12797  const char * const swig_method_name = "useShowerPlugin";
12798  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12799  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12800 #else
12801  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "useShowerPlugin", NULL);
12802 #endif
12803  if (!result) {
12804  PyObject *error = PyErr_Occurred();
12805  if (error) {
12806  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.useShowerPlugin'");
12807  }
12808  }
12809  bool swig_val;
12810  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12811  if (!SWIG_IsOK(swig_res)) {
12812  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12813  }
12814  c_result = static_cast< bool >(swig_val);
12815  return (bool) c_result;
12816 }
12817 
12818 
12819 bool SwigDirector_MergingHooks::canVetoStep() {
12820  bool c_result;
12821  if (!swig_get_self()) {
12822  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12823  }
12824 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12825  const size_t swig_method_index = 14;
12826  const char * const swig_method_name = "canVetoStep";
12827  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12828  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12829 #else
12830  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoStep", NULL);
12831 #endif
12832  if (!result) {
12833  PyObject *error = PyErr_Occurred();
12834  if (error) {
12835  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.canVetoStep'");
12836  }
12837  }
12838  bool swig_val;
12839  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12840  if (!SWIG_IsOK(swig_res)) {
12841  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12842  }
12843  c_result = static_cast< bool >(swig_val);
12844  return (bool) c_result;
12845 }
12846 
12847 
12848 bool SwigDirector_MergingHooks::doVetoStep(Pythia8::Event const &process, Pythia8::Event const &event, bool doResonance) {
12849  bool c_result;
12851  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&process), SWIGTYPE_p_Pythia8__Event, 0 );
12853  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event, 0 );
12855  obj2 = SWIG_From_bool(static_cast< bool >(doResonance));
12856  if (!swig_get_self()) {
12857  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12858  }
12859 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12860  const size_t swig_method_index = 15;
12861  const char * const swig_method_name = "doVetoStep";
12862  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12863  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
12864 #else
12865  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoStep", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
12866 #endif
12867  if (!result) {
12868  PyObject *error = PyErr_Occurred();
12869  if (error) {
12870  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.doVetoStep'");
12871  }
12872  }
12873  bool swig_val;
12874  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12875  if (!SWIG_IsOK(swig_res)) {
12876  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12877  }
12878  c_result = static_cast< bool >(swig_val);
12879  return (bool) c_result;
12880 }
12881 
12882 
12883 bool SwigDirector_MergingHooks::setShowerStartingScales(bool isTrial, bool doMergeFirstEmm, double &pTscaleIn, Pythia8::Event const &event, double &pTmaxFSRIn, bool &limitPTmaxFSRin, double &pTmaxISRIn, bool &limitPTmaxISRin, double &pTmaxMPIIn, bool &limitPTmaxMPIin) {
12884  bool c_result;
12886  obj0 = SWIG_From_bool(static_cast< bool >(isTrial));
12888  obj1 = SWIG_From_bool(static_cast< bool >(doMergeFirstEmm));
12890  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&pTscaleIn), SWIGTYPE_p_double, 0 );
12892  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event, 0 );
12894  obj4 = SWIG_NewPointerObj(SWIG_as_voidptr(&pTmaxFSRIn), SWIGTYPE_p_double, 0 );
12896  obj5 = SWIG_NewPointerObj(SWIG_as_voidptr(&limitPTmaxFSRin), SWIGTYPE_p_bool, 0 );
12898  obj6 = SWIG_NewPointerObj(SWIG_as_voidptr(&pTmaxISRIn), SWIGTYPE_p_double, 0 );
12900  obj7 = SWIG_NewPointerObj(SWIG_as_voidptr(&limitPTmaxISRin), SWIGTYPE_p_bool, 0 );
12902  obj8 = SWIG_NewPointerObj(SWIG_as_voidptr(&pTmaxMPIIn), SWIGTYPE_p_double, 0 );
12904  obj9 = SWIG_NewPointerObj(SWIG_as_voidptr(&limitPTmaxMPIin), SWIGTYPE_p_bool, 0 );
12905  if (!swig_get_self()) {
12906  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
12907  }
12908 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12909  const size_t swig_method_index = 17;
12910  const char * const swig_method_name = "setShowerStartingScales";
12911  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12912  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9);
12913 #else
12914  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setShowerStartingScales", (char *)"(OOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9);
12915 #endif
12916  if (!result) {
12917  PyObject *error = PyErr_Occurred();
12918  if (error) {
12919  Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.setShowerStartingScales'");
12920  }
12921  }
12922  bool swig_val;
12923  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12924  if (!SWIG_IsOK(swig_res)) {
12925  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12926  }
12927  c_result = static_cast< bool >(swig_val);
12928  return (bool) c_result;
12929 }
12930 
12931 
12932 SwigDirector_SigmaProcess::SwigDirector_SigmaProcess(PyObject *self): Pythia8::SigmaProcess(), Swig::Director(self) {
12933  SWIG_DIRECTOR_RGTR((Pythia8::SigmaProcess *)this, this);
12934 }
12935 
12936 
12937 
12938 
12939 SwigDirector_SigmaProcess::~SwigDirector_SigmaProcess() {
12940 }
12941 
12942 void SwigDirector_SigmaProcess::initProc() {
12943  if (!swig_get_self()) {
12944  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
12945  }
12946 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12947  const size_t swig_method_index = 0;
12948  const char * const swig_method_name = "initProc";
12949  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12950  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12951 #else
12952  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initProc", NULL);
12953 #endif
12954  if (!result) {
12955  PyObject *error = PyErr_Occurred();
12956  if (error) {
12957  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.initProc'");
12958  }
12959  }
12960 }
12961 
12962 
12963 bool SwigDirector_SigmaProcess::initFlux() {
12964  bool c_result;
12965  if (!swig_get_self()) {
12966  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
12967  }
12968 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
12969  const size_t swig_method_index = 1;
12970  const char * const swig_method_name = "initFlux";
12971  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
12972  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
12973 #else
12974  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initFlux", NULL);
12975 #endif
12976  if (!result) {
12977  PyObject *error = PyErr_Occurred();
12978  if (error) {
12979  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.initFlux'");
12980  }
12981  }
12982  bool swig_val;
12983  int swig_res = SWIG_AsVal_bool(result, &swig_val);
12984  if (!SWIG_IsOK(swig_res)) {
12985  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
12986  }
12987  c_result = static_cast< bool >(swig_val);
12988  return (bool) c_result;
12989 }
12990 
12991 
12992 void SwigDirector_SigmaProcess::set1Kin(double arg0, double arg1, double arg2) {
12994  obj0 = SWIG_From_double(static_cast< double >(arg0));
12996  obj1 = SWIG_From_double(static_cast< double >(arg1));
12998  obj2 = SWIG_From_double(static_cast< double >(arg2));
12999  if (!swig_get_self()) {
13000  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13001  }
13002 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13003  const size_t swig_method_index = 2;
13004  const char * const swig_method_name = "set1Kin";
13005  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13006  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
13007 #else
13008  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"set1Kin", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
13009 #endif
13010  if (!result) {
13011  PyObject *error = PyErr_Occurred();
13012  if (error) {
13013  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.set1Kin'");
13014  }
13015  }
13016 }
13017 
13018 
13019 void SwigDirector_SigmaProcess::set2Kin(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, double arg7) {
13021  obj0 = SWIG_From_double(static_cast< double >(arg0));
13023  obj1 = SWIG_From_double(static_cast< double >(arg1));
13025  obj2 = SWIG_From_double(static_cast< double >(arg2));
13027  obj3 = SWIG_From_double(static_cast< double >(arg3));
13029  obj4 = SWIG_From_double(static_cast< double >(arg4));
13031  obj5 = SWIG_From_double(static_cast< double >(arg5));
13033  obj6 = SWIG_From_double(static_cast< double >(arg6));
13035  obj7 = SWIG_From_double(static_cast< double >(arg7));
13036  if (!swig_get_self()) {
13037  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13038  }
13039 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13040  const size_t swig_method_index = 3;
13041  const char * const swig_method_name = "set2Kin";
13042  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13043  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7);
13044 #else
13045  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"set2Kin", (char *)"(OOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7);
13046 #endif
13047  if (!result) {
13048  PyObject *error = PyErr_Occurred();
13049  if (error) {
13050  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.set2Kin'");
13051  }
13052  }
13053 }
13054 
13055 
13056 void SwigDirector_SigmaProcess::set2KinMPI(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, bool arg7, double arg8, double arg9) {
13058  obj0 = SWIG_From_double(static_cast< double >(arg0));
13060  obj1 = SWIG_From_double(static_cast< double >(arg1));
13062  obj2 = SWIG_From_double(static_cast< double >(arg2));
13064  obj3 = SWIG_From_double(static_cast< double >(arg3));
13066  obj4 = SWIG_From_double(static_cast< double >(arg4));
13068  obj5 = SWIG_From_double(static_cast< double >(arg5));
13070  obj6 = SWIG_From_double(static_cast< double >(arg6));
13072  obj7 = SWIG_From_bool(static_cast< bool >(arg7));
13074  obj8 = SWIG_From_double(static_cast< double >(arg8));
13076  obj9 = SWIG_From_double(static_cast< double >(arg9));
13077  if (!swig_get_self()) {
13078  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13079  }
13080 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13081  const size_t swig_method_index = 4;
13082  const char * const swig_method_name = "set2KinMPI";
13083  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13084  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9);
13085 #else
13086  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"set2KinMPI", (char *)"(OOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9);
13087 #endif
13088  if (!result) {
13089  PyObject *error = PyErr_Occurred();
13090  if (error) {
13091  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.set2KinMPI'");
13092  }
13093  }
13094 }
13095 
13096 
13097 void SwigDirector_SigmaProcess::set3Kin(double arg0, double arg1, double arg2, Pythia8::Vec4 arg3, Pythia8::Vec4 arg4, Pythia8::Vec4 arg5, double arg6, double arg7, double arg8, double arg9, double arg10, double arg11) {
13099  obj0 = SWIG_From_double(static_cast< double >(arg0));
13101  obj1 = SWIG_From_double(static_cast< double >(arg1));
13103  obj2 = SWIG_From_double(static_cast< double >(arg2));
13105  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg3), SWIGTYPE_p_Pythia8__Vec4, 0 );
13107  obj4 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg4), SWIGTYPE_p_Pythia8__Vec4, 0 );
13109  obj5 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg5), SWIGTYPE_p_Pythia8__Vec4, 0 );
13111  obj6 = SWIG_From_double(static_cast< double >(arg6));
13113  obj7 = SWIG_From_double(static_cast< double >(arg7));
13115  obj8 = SWIG_From_double(static_cast< double >(arg8));
13117  obj9 = SWIG_From_double(static_cast< double >(arg9));
13118  swig::SwigVar_PyObject obj10;
13119  obj10 = SWIG_From_double(static_cast< double >(arg10));
13120  swig::SwigVar_PyObject obj11;
13121  obj11 = SWIG_From_double(static_cast< double >(arg11));
13122  if (!swig_get_self()) {
13123  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13124  }
13125 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13126  const size_t swig_method_index = 5;
13127  const char * const swig_method_name = "set3Kin";
13128  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13129  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9,(PyObject *)obj10,(PyObject *)obj11);
13130 #else
13131  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"set3Kin", (char *)"(OOOOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9,(PyObject *)obj10,(PyObject *)obj11);
13132 #endif
13133  if (!result) {
13134  PyObject *error = PyErr_Occurred();
13135  if (error) {
13136  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.set3Kin'");
13137  }
13138  }
13139 }
13140 
13141 
13142 void SwigDirector_SigmaProcess::sigmaKin() {
13143  if (!swig_get_self()) {
13144  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13145  }
13146 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13147  const size_t swig_method_index = 6;
13148  const char * const swig_method_name = "sigmaKin";
13149  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13150  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13151 #else
13152  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "sigmaKin", NULL);
13153 #endif
13154  if (!result) {
13155  PyObject *error = PyErr_Occurred();
13156  if (error) {
13157  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.sigmaKin'");
13158  }
13159  }
13160 }
13161 
13162 
13163 double SwigDirector_SigmaProcess::sigmaHat() {
13164  double c_result;
13165  if (!swig_get_self()) {
13166  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13167  }
13168 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13169  const size_t swig_method_index = 7;
13170  const char * const swig_method_name = "sigmaHat";
13171  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13172  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13173 #else
13174  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "sigmaHat", NULL);
13175 #endif
13176  if (!result) {
13177  PyObject *error = PyErr_Occurred();
13178  if (error) {
13179  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.sigmaHat'");
13180  }
13181  }
13182  double swig_val;
13183  int swig_res = SWIG_AsVal_double(result, &swig_val);
13184  if (!SWIG_IsOK(swig_res)) {
13185  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
13186  }
13187  c_result = static_cast< double >(swig_val);
13188  return (double) c_result;
13189 }
13190 
13191 
13192 double SwigDirector_SigmaProcess::sigmaHatWrap(int id1in, int id2in) {
13193  double c_result;
13195  obj0 = SWIG_From_int(static_cast< int >(id1in));
13197  obj1 = SWIG_From_int(static_cast< int >(id2in));
13198  if (!swig_get_self()) {
13199  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13200  }
13201 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13202  const size_t swig_method_index = 8;
13203  const char * const swig_method_name = "sigmaHatWrap";
13204  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13205  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
13206 #else
13207  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"sigmaHatWrap", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
13208 #endif
13209  if (!result) {
13210  PyObject *error = PyErr_Occurred();
13211  if (error) {
13212  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.sigmaHatWrap'");
13213  }
13214  }
13215  double swig_val;
13216  int swig_res = SWIG_AsVal_double(result, &swig_val);
13217  if (!SWIG_IsOK(swig_res)) {
13218  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
13219  }
13220  c_result = static_cast< double >(swig_val);
13221  return (double) c_result;
13222 }
13223 
13224 
13225 double SwigDirector_SigmaProcess::sigmaPDF(bool initPS, bool samexGamma, bool useNewXvalues, double x1New, double x2New) {
13226  double c_result;
13228  obj0 = SWIG_From_bool(static_cast< bool >(initPS));
13230  obj1 = SWIG_From_bool(static_cast< bool >(samexGamma));
13232  obj2 = SWIG_From_bool(static_cast< bool >(useNewXvalues));
13234  obj3 = SWIG_From_double(static_cast< double >(x1New));
13236  obj4 = SWIG_From_double(static_cast< double >(x2New));
13237  if (!swig_get_self()) {
13238  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13239  }
13240 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13241  const size_t swig_method_index = 11;
13242  const char * const swig_method_name = "sigmaPDF";
13243  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13244  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
13245 #else
13246  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"sigmaPDF", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
13247 #endif
13248  if (!result) {
13249  PyObject *error = PyErr_Occurred();
13250  if (error) {
13251  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.sigmaPDF'");
13252  }
13253  }
13254  double swig_val;
13255  int swig_res = SWIG_AsVal_double(result, &swig_val);
13256  if (!SWIG_IsOK(swig_res)) {
13257  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
13258  }
13259  c_result = static_cast< double >(swig_val);
13260  return (double) c_result;
13261 }
13262 
13263 
13264 void SwigDirector_SigmaProcess::setIdColAcol() {
13265  if (!swig_get_self()) {
13266  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13267  }
13268 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13269  const size_t swig_method_index = 17;
13270  const char * const swig_method_name = "setIdColAcol";
13271  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13272  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13273 #else
13274  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "setIdColAcol", NULL);
13275 #endif
13276  if (!result) {
13277  PyObject *error = PyErr_Occurred();
13278  if (error) {
13279  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.setIdColAcol'");
13280  }
13281  }
13282 }
13283 
13284 
13285 bool SwigDirector_SigmaProcess::final2KinMPI(int arg0, int arg1, Pythia8::Vec4 arg2, Pythia8::Vec4 arg3, double arg4, double arg5) {
13286  bool c_result;
13288  obj0 = SWIG_From_int(static_cast< int >(arg0));
13290  obj1 = SWIG_From_int(static_cast< int >(arg1));
13292  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg2), SWIGTYPE_p_Pythia8__Vec4, 0 );
13294  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg3), SWIGTYPE_p_Pythia8__Vec4, 0 );
13296  obj4 = SWIG_From_double(static_cast< double >(arg4));
13298  obj5 = SWIG_From_double(static_cast< double >(arg5));
13299  if (!swig_get_self()) {
13300  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13301  }
13302 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13303  const size_t swig_method_index = 18;
13304  const char * const swig_method_name = "final2KinMPI";
13305  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13306  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5);
13307 #else
13308  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"final2KinMPI", (char *)"(OOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5);
13309 #endif
13310  if (!result) {
13311  PyObject *error = PyErr_Occurred();
13312  if (error) {
13313  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.final2KinMPI'");
13314  }
13315  }
13316  bool swig_val;
13317  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13318  if (!SWIG_IsOK(swig_res)) {
13319  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13320  }
13321  c_result = static_cast< bool >(swig_val);
13322  return (bool) c_result;
13323 }
13324 
13325 
13326 double SwigDirector_SigmaProcess::weightDecayFlav(Pythia8::Event &arg0) {
13327  double c_result;
13329  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
13330  if (!swig_get_self()) {
13331  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13332  }
13333 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13334  const size_t swig_method_index = 25;
13335  const char * const swig_method_name = "weightDecayFlav";
13336  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13337  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
13338 #else
13339  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"weightDecayFlav", (char *)"(O)" ,(PyObject *)obj0);
13340 #endif
13341  if (!result) {
13342  PyObject *error = PyErr_Occurred();
13343  if (error) {
13344  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.weightDecayFlav'");
13345  }
13346  }
13347  double swig_val;
13348  int swig_res = SWIG_AsVal_double(result, &swig_val);
13349  if (!SWIG_IsOK(swig_res)) {
13350  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
13351  }
13352  c_result = static_cast< double >(swig_val);
13353  return (double) c_result;
13354 }
13355 
13356 
13357 double SwigDirector_SigmaProcess::weightDecay(Pythia8::Event &arg0, int arg1, int arg2) {
13358  double c_result;
13360  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
13362  obj1 = SWIG_From_int(static_cast< int >(arg1));
13364  obj2 = SWIG_From_int(static_cast< int >(arg2));
13365  if (!swig_get_self()) {
13366  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13367  }
13368 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13369  const size_t swig_method_index = 26;
13370  const char * const swig_method_name = "weightDecay";
13371  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13372  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
13373 #else
13374  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"weightDecay", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
13375 #endif
13376  if (!result) {
13377  PyObject *error = PyErr_Occurred();
13378  if (error) {
13379  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.weightDecay'");
13380  }
13381  }
13382  double swig_val;
13383  int swig_res = SWIG_AsVal_double(result, &swig_val);
13384  if (!SWIG_IsOK(swig_res)) {
13385  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
13386  }
13387  c_result = static_cast< double >(swig_val);
13388  return (double) c_result;
13389 }
13390 
13391 
13392 void SwigDirector_SigmaProcess::setScale() {
13393  if (!swig_get_self()) {
13394  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13395  }
13396 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13397  const size_t swig_method_index = 27;
13398  const char * const swig_method_name = "setScale";
13399  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13400  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13401 #else
13402  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "setScale", NULL);
13403 #endif
13404  if (!result) {
13405  PyObject *error = PyErr_Occurred();
13406  if (error) {
13407  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.setScale'");
13408  }
13409  }
13410 }
13411 
13412 
13413 std::string SwigDirector_SigmaProcess::name() const {
13414  std::string c_result;
13415  if (!swig_get_self()) {
13416  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13417  }
13418 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13419  const size_t swig_method_index = 28;
13420  const char * const swig_method_name = "name";
13421  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13422  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13423 #else
13424  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "name", NULL);
13425 #endif
13426  if (!result) {
13427  PyObject *error = PyErr_Occurred();
13428  if (error) {
13429  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.name'");
13430  }
13431  }
13432  std::string *swig_optr = 0;
13433  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
13434  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
13435  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
13436  }
13437  c_result = *swig_optr;
13438  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
13439  return (std::string) c_result;
13440 }
13441 
13442 
13443 int SwigDirector_SigmaProcess::code() const {
13444  int c_result;
13445  if (!swig_get_self()) {
13446  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13447  }
13448 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13449  const size_t swig_method_index = 29;
13450  const char * const swig_method_name = "code";
13451  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13452  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13453 #else
13454  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "code", NULL);
13455 #endif
13456  if (!result) {
13457  PyObject *error = PyErr_Occurred();
13458  if (error) {
13459  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.code'");
13460  }
13461  }
13462  int swig_val;
13463  int swig_res = SWIG_AsVal_int(result, &swig_val);
13464  if (!SWIG_IsOK(swig_res)) {
13465  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
13466  }
13467  c_result = static_cast< int >(swig_val);
13468  return (int) c_result;
13469 }
13470 
13471 
13472 int SwigDirector_SigmaProcess::nFinal() const {
13473  int c_result;
13474  if (!swig_get_self()) {
13475  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13476  }
13477 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13478  const size_t swig_method_index = 30;
13479  const char * const swig_method_name = "nFinal";
13480  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13481  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13482 #else
13483  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "nFinal", NULL);
13484 #endif
13485  if (!result) {
13486  PyObject *error = PyErr_Occurred();
13487  if (error) {
13488  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.nFinal'");
13489  }
13490  }
13491  int swig_val;
13492  int swig_res = SWIG_AsVal_int(result, &swig_val);
13493  if (!SWIG_IsOK(swig_res)) {
13494  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
13495  }
13496  c_result = static_cast< int >(swig_val);
13497  return (int) c_result;
13498 }
13499 
13500 
13501 std::string SwigDirector_SigmaProcess::inFlux() const {
13502  std::string c_result;
13503  if (!swig_get_self()) {
13504  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13505  }
13506 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13507  const size_t swig_method_index = 31;
13508  const char * const swig_method_name = "inFlux";
13509  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13510  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13511 #else
13512  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "inFlux", NULL);
13513 #endif
13514  if (!result) {
13515  PyObject *error = PyErr_Occurred();
13516  if (error) {
13517  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.inFlux'");
13518  }
13519  }
13520  std::string *swig_optr = 0;
13521  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
13522  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
13523  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
13524  }
13525  c_result = *swig_optr;
13526  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
13527  return (std::string) c_result;
13528 }
13529 
13530 
13531 bool SwigDirector_SigmaProcess::convert2mb() const {
13532  bool c_result;
13533  if (!swig_get_self()) {
13534  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13535  }
13536 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13537  const size_t swig_method_index = 32;
13538  const char * const swig_method_name = "convert2mb";
13539  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13540  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13541 #else
13542  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "convert2mb", NULL);
13543 #endif
13544  if (!result) {
13545  PyObject *error = PyErr_Occurred();
13546  if (error) {
13547  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.convert2mb'");
13548  }
13549  }
13550  bool swig_val;
13551  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13552  if (!SWIG_IsOK(swig_res)) {
13553  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13554  }
13555  c_result = static_cast< bool >(swig_val);
13556  return (bool) c_result;
13557 }
13558 
13559 
13560 bool SwigDirector_SigmaProcess::convertM2() const {
13561  bool c_result;
13562  if (!swig_get_self()) {
13563  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13564  }
13565 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13566  const size_t swig_method_index = 33;
13567  const char * const swig_method_name = "convertM2";
13568  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13569  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13570 #else
13571  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "convertM2", NULL);
13572 #endif
13573  if (!result) {
13574  PyObject *error = PyErr_Occurred();
13575  if (error) {
13576  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.convertM2'");
13577  }
13578  }
13579  bool swig_val;
13580  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13581  if (!SWIG_IsOK(swig_res)) {
13582  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13583  }
13584  c_result = static_cast< bool >(swig_val);
13585  return (bool) c_result;
13586 }
13587 
13588 
13589 bool SwigDirector_SigmaProcess::isLHA() const {
13590  bool c_result;
13591  if (!swig_get_self()) {
13592  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13593  }
13594 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13595  const size_t swig_method_index = 34;
13596  const char * const swig_method_name = "isLHA";
13597  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13598  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13599 #else
13600  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isLHA", NULL);
13601 #endif
13602  if (!result) {
13603  PyObject *error = PyErr_Occurred();
13604  if (error) {
13605  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isLHA'");
13606  }
13607  }
13608  bool swig_val;
13609  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13610  if (!SWIG_IsOK(swig_res)) {
13611  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13612  }
13613  c_result = static_cast< bool >(swig_val);
13614  return (bool) c_result;
13615 }
13616 
13617 
13618 bool SwigDirector_SigmaProcess::isNonDiff() const {
13619  bool c_result;
13620  if (!swig_get_self()) {
13621  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13622  }
13623 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13624  const size_t swig_method_index = 35;
13625  const char * const swig_method_name = "isNonDiff";
13626  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13627  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13628 #else
13629  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isNonDiff", NULL);
13630 #endif
13631  if (!result) {
13632  PyObject *error = PyErr_Occurred();
13633  if (error) {
13634  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isNonDiff'");
13635  }
13636  }
13637  bool swig_val;
13638  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13639  if (!SWIG_IsOK(swig_res)) {
13640  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13641  }
13642  c_result = static_cast< bool >(swig_val);
13643  return (bool) c_result;
13644 }
13645 
13646 
13647 bool SwigDirector_SigmaProcess::isResolved() const {
13648  bool c_result;
13649  if (!swig_get_self()) {
13650  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13651  }
13652 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13653  const size_t swig_method_index = 36;
13654  const char * const swig_method_name = "isResolved";
13655  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13656  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13657 #else
13658  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isResolved", NULL);
13659 #endif
13660  if (!result) {
13661  PyObject *error = PyErr_Occurred();
13662  if (error) {
13663  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isResolved'");
13664  }
13665  }
13666  bool swig_val;
13667  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13668  if (!SWIG_IsOK(swig_res)) {
13669  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13670  }
13671  c_result = static_cast< bool >(swig_val);
13672  return (bool) c_result;
13673 }
13674 
13675 
13676 bool SwigDirector_SigmaProcess::isDiffA() const {
13677  bool c_result;
13678  if (!swig_get_self()) {
13679  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13680  }
13681 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13682  const size_t swig_method_index = 37;
13683  const char * const swig_method_name = "isDiffA";
13684  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13685  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13686 #else
13687  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isDiffA", NULL);
13688 #endif
13689  if (!result) {
13690  PyObject *error = PyErr_Occurred();
13691  if (error) {
13692  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isDiffA'");
13693  }
13694  }
13695  bool swig_val;
13696  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13697  if (!SWIG_IsOK(swig_res)) {
13698  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13699  }
13700  c_result = static_cast< bool >(swig_val);
13701  return (bool) c_result;
13702 }
13703 
13704 
13705 bool SwigDirector_SigmaProcess::isDiffB() const {
13706  bool c_result;
13707  if (!swig_get_self()) {
13708  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13709  }
13710 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13711  const size_t swig_method_index = 38;
13712  const char * const swig_method_name = "isDiffB";
13713  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13714  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13715 #else
13716  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isDiffB", NULL);
13717 #endif
13718  if (!result) {
13719  PyObject *error = PyErr_Occurred();
13720  if (error) {
13721  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isDiffB'");
13722  }
13723  }
13724  bool swig_val;
13725  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13726  if (!SWIG_IsOK(swig_res)) {
13727  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13728  }
13729  c_result = static_cast< bool >(swig_val);
13730  return (bool) c_result;
13731 }
13732 
13733 
13734 bool SwigDirector_SigmaProcess::isDiffC() const {
13735  bool c_result;
13736  if (!swig_get_self()) {
13737  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13738  }
13739 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13740  const size_t swig_method_index = 39;
13741  const char * const swig_method_name = "isDiffC";
13742  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13743  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13744 #else
13745  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isDiffC", NULL);
13746 #endif
13747  if (!result) {
13748  PyObject *error = PyErr_Occurred();
13749  if (error) {
13750  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isDiffC'");
13751  }
13752  }
13753  bool swig_val;
13754  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13755  if (!SWIG_IsOK(swig_res)) {
13756  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13757  }
13758  c_result = static_cast< bool >(swig_val);
13759  return (bool) c_result;
13760 }
13761 
13762 
13763 bool SwigDirector_SigmaProcess::isSUSY() const {
13764  bool c_result;
13765  if (!swig_get_self()) {
13766  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13767  }
13768 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13769  const size_t swig_method_index = 40;
13770  const char * const swig_method_name = "isSUSY";
13771  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13772  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13773 #else
13774  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isSUSY", NULL);
13775 #endif
13776  if (!result) {
13777  PyObject *error = PyErr_Occurred();
13778  if (error) {
13779  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isSUSY'");
13780  }
13781  }
13782  bool swig_val;
13783  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13784  if (!SWIG_IsOK(swig_res)) {
13785  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13786  }
13787  c_result = static_cast< bool >(swig_val);
13788  return (bool) c_result;
13789 }
13790 
13791 
13792 bool SwigDirector_SigmaProcess::allowNegativeSigma() const {
13793  bool c_result;
13794  if (!swig_get_self()) {
13795  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13796  }
13797 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13798  const size_t swig_method_index = 41;
13799  const char * const swig_method_name = "allowNegativeSigma";
13800  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13801  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13802 #else
13803  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "allowNegativeSigma", NULL);
13804 #endif
13805  if (!result) {
13806  PyObject *error = PyErr_Occurred();
13807  if (error) {
13808  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.allowNegativeSigma'");
13809  }
13810  }
13811  bool swig_val;
13812  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13813  if (!SWIG_IsOK(swig_res)) {
13814  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13815  }
13816  c_result = static_cast< bool >(swig_val);
13817  return (bool) c_result;
13818 }
13819 
13820 
13821 int SwigDirector_SigmaProcess::id3Mass() const {
13822  int c_result;
13823  if (!swig_get_self()) {
13824  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13825  }
13826 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13827  const size_t swig_method_index = 42;
13828  const char * const swig_method_name = "id3Mass";
13829  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13830  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13831 #else
13832  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "id3Mass", NULL);
13833 #endif
13834  if (!result) {
13835  PyObject *error = PyErr_Occurred();
13836  if (error) {
13837  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.id3Mass'");
13838  }
13839  }
13840  int swig_val;
13841  int swig_res = SWIG_AsVal_int(result, &swig_val);
13842  if (!SWIG_IsOK(swig_res)) {
13843  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
13844  }
13845  c_result = static_cast< int >(swig_val);
13846  return (int) c_result;
13847 }
13848 
13849 
13850 int SwigDirector_SigmaProcess::id4Mass() const {
13851  int c_result;
13852  if (!swig_get_self()) {
13853  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13854  }
13855 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13856  const size_t swig_method_index = 43;
13857  const char * const swig_method_name = "id4Mass";
13858  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13859  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13860 #else
13861  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "id4Mass", NULL);
13862 #endif
13863  if (!result) {
13864  PyObject *error = PyErr_Occurred();
13865  if (error) {
13866  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.id4Mass'");
13867  }
13868  }
13869  int swig_val;
13870  int swig_res = SWIG_AsVal_int(result, &swig_val);
13871  if (!SWIG_IsOK(swig_res)) {
13872  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
13873  }
13874  c_result = static_cast< int >(swig_val);
13875  return (int) c_result;
13876 }
13877 
13878 
13879 int SwigDirector_SigmaProcess::id5Mass() const {
13880  int c_result;
13881  if (!swig_get_self()) {
13882  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13883  }
13884 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13885  const size_t swig_method_index = 44;
13886  const char * const swig_method_name = "id5Mass";
13887  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13888  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13889 #else
13890  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "id5Mass", NULL);
13891 #endif
13892  if (!result) {
13893  PyObject *error = PyErr_Occurred();
13894  if (error) {
13895  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.id5Mass'");
13896  }
13897  }
13898  int swig_val;
13899  int swig_res = SWIG_AsVal_int(result, &swig_val);
13900  if (!SWIG_IsOK(swig_res)) {
13901  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
13902  }
13903  c_result = static_cast< int >(swig_val);
13904  return (int) c_result;
13905 }
13906 
13907 
13908 int SwigDirector_SigmaProcess::resonanceA() const {
13909  int c_result;
13910  if (!swig_get_self()) {
13911  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13912  }
13913 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13914  const size_t swig_method_index = 45;
13915  const char * const swig_method_name = "resonanceA";
13916  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13917  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13918 #else
13919  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "resonanceA", NULL);
13920 #endif
13921  if (!result) {
13922  PyObject *error = PyErr_Occurred();
13923  if (error) {
13924  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.resonanceA'");
13925  }
13926  }
13927  int swig_val;
13928  int swig_res = SWIG_AsVal_int(result, &swig_val);
13929  if (!SWIG_IsOK(swig_res)) {
13930  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
13931  }
13932  c_result = static_cast< int >(swig_val);
13933  return (int) c_result;
13934 }
13935 
13936 
13937 int SwigDirector_SigmaProcess::resonanceB() const {
13938  int c_result;
13939  if (!swig_get_self()) {
13940  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13941  }
13942 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13943  const size_t swig_method_index = 46;
13944  const char * const swig_method_name = "resonanceB";
13945  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13946  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13947 #else
13948  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "resonanceB", NULL);
13949 #endif
13950  if (!result) {
13951  PyObject *error = PyErr_Occurred();
13952  if (error) {
13953  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.resonanceB'");
13954  }
13955  }
13956  int swig_val;
13957  int swig_res = SWIG_AsVal_int(result, &swig_val);
13958  if (!SWIG_IsOK(swig_res)) {
13959  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
13960  }
13961  c_result = static_cast< int >(swig_val);
13962  return (int) c_result;
13963 }
13964 
13965 
13966 bool SwigDirector_SigmaProcess::isSChannel() const {
13967  bool c_result;
13968  if (!swig_get_self()) {
13969  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13970  }
13971 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
13972  const size_t swig_method_index = 47;
13973  const char * const swig_method_name = "isSChannel";
13974  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
13975  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
13976 #else
13977  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isSChannel", NULL);
13978 #endif
13979  if (!result) {
13980  PyObject *error = PyErr_Occurred();
13981  if (error) {
13982  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isSChannel'");
13983  }
13984  }
13985  bool swig_val;
13986  int swig_res = SWIG_AsVal_bool(result, &swig_val);
13987  if (!SWIG_IsOK(swig_res)) {
13988  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
13989  }
13990  c_result = static_cast< bool >(swig_val);
13991  return (bool) c_result;
13992 }
13993 
13994 
13995 int SwigDirector_SigmaProcess::idSChannel() const {
13996  int c_result;
13997  if (!swig_get_self()) {
13998  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
13999  }
14000 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14001  const size_t swig_method_index = 48;
14002  const char * const swig_method_name = "idSChannel";
14003  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14004  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14005 #else
14006  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "idSChannel", NULL);
14007 #endif
14008  if (!result) {
14009  PyObject *error = PyErr_Occurred();
14010  if (error) {
14011  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.idSChannel'");
14012  }
14013  }
14014  int swig_val;
14015  int swig_res = SWIG_AsVal_int(result, &swig_val);
14016  if (!SWIG_IsOK(swig_res)) {
14017  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
14018  }
14019  c_result = static_cast< int >(swig_val);
14020  return (int) c_result;
14021 }
14022 
14023 
14024 bool SwigDirector_SigmaProcess::isQCD3body() const {
14025  bool c_result;
14026  if (!swig_get_self()) {
14027  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
14028  }
14029 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14030  const size_t swig_method_index = 49;
14031  const char * const swig_method_name = "isQCD3body";
14032  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14033  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14034 #else
14035  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isQCD3body", NULL);
14036 #endif
14037  if (!result) {
14038  PyObject *error = PyErr_Occurred();
14039  if (error) {
14040  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isQCD3body'");
14041  }
14042  }
14043  bool swig_val;
14044  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14045  if (!SWIG_IsOK(swig_res)) {
14046  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14047  }
14048  c_result = static_cast< bool >(swig_val);
14049  return (bool) c_result;
14050 }
14051 
14052 
14053 int SwigDirector_SigmaProcess::idTchan1() const {
14054  int c_result;
14055  if (!swig_get_self()) {
14056  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
14057  }
14058 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14059  const size_t swig_method_index = 50;
14060  const char * const swig_method_name = "idTchan1";
14061  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14062  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14063 #else
14064  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "idTchan1", NULL);
14065 #endif
14066  if (!result) {
14067  PyObject *error = PyErr_Occurred();
14068  if (error) {
14069  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.idTchan1'");
14070  }
14071  }
14072  int swig_val;
14073  int swig_res = SWIG_AsVal_int(result, &swig_val);
14074  if (!SWIG_IsOK(swig_res)) {
14075  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
14076  }
14077  c_result = static_cast< int >(swig_val);
14078  return (int) c_result;
14079 }
14080 
14081 
14082 int SwigDirector_SigmaProcess::idTchan2() const {
14083  int c_result;
14084  if (!swig_get_self()) {
14085  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
14086  }
14087 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14088  const size_t swig_method_index = 51;
14089  const char * const swig_method_name = "idTchan2";
14090  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14091  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14092 #else
14093  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "idTchan2", NULL);
14094 #endif
14095  if (!result) {
14096  PyObject *error = PyErr_Occurred();
14097  if (error) {
14098  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.idTchan2'");
14099  }
14100  }
14101  int swig_val;
14102  int swig_res = SWIG_AsVal_int(result, &swig_val);
14103  if (!SWIG_IsOK(swig_res)) {
14104  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
14105  }
14106  c_result = static_cast< int >(swig_val);
14107  return (int) c_result;
14108 }
14109 
14110 
14111 double SwigDirector_SigmaProcess::tChanFracPow1() const {
14112  double c_result;
14113  if (!swig_get_self()) {
14114  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
14115  }
14116 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14117  const size_t swig_method_index = 52;
14118  const char * const swig_method_name = "tChanFracPow1";
14119  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14120  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14121 #else
14122  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "tChanFracPow1", NULL);
14123 #endif
14124  if (!result) {
14125  PyObject *error = PyErr_Occurred();
14126  if (error) {
14127  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.tChanFracPow1'");
14128  }
14129  }
14130  double swig_val;
14131  int swig_res = SWIG_AsVal_double(result, &swig_val);
14132  if (!SWIG_IsOK(swig_res)) {
14133  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
14134  }
14135  c_result = static_cast< double >(swig_val);
14136  return (double) c_result;
14137 }
14138 
14139 
14140 double SwigDirector_SigmaProcess::tChanFracPow2() const {
14141  double c_result;
14142  if (!swig_get_self()) {
14143  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
14144  }
14145 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14146  const size_t swig_method_index = 53;
14147  const char * const swig_method_name = "tChanFracPow2";
14148  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14149  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14150 #else
14151  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "tChanFracPow2", NULL);
14152 #endif
14153  if (!result) {
14154  PyObject *error = PyErr_Occurred();
14155  if (error) {
14156  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.tChanFracPow2'");
14157  }
14158  }
14159  double swig_val;
14160  int swig_res = SWIG_AsVal_double(result, &swig_val);
14161  if (!SWIG_IsOK(swig_res)) {
14162  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
14163  }
14164  c_result = static_cast< double >(swig_val);
14165  return (double) c_result;
14166 }
14167 
14168 
14169 bool SwigDirector_SigmaProcess::useMirrorWeight() const {
14170  bool c_result;
14171  if (!swig_get_self()) {
14172  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
14173  }
14174 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14175  const size_t swig_method_index = 54;
14176  const char * const swig_method_name = "useMirrorWeight";
14177  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14178  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14179 #else
14180  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "useMirrorWeight", NULL);
14181 #endif
14182  if (!result) {
14183  PyObject *error = PyErr_Occurred();
14184  if (error) {
14185  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.useMirrorWeight'");
14186  }
14187  }
14188  bool swig_val;
14189  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14190  if (!SWIG_IsOK(swig_res)) {
14191  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14192  }
14193  c_result = static_cast< bool >(swig_val);
14194  return (bool) c_result;
14195 }
14196 
14197 
14198 int SwigDirector_SigmaProcess::gmZmode() const {
14199  int c_result;
14200  if (!swig_get_self()) {
14201  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
14202  }
14203 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14204  const size_t swig_method_index = 55;
14205  const char * const swig_method_name = "gmZmode";
14206  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14207  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14208 #else
14209  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "gmZmode", NULL);
14210 #endif
14211  if (!result) {
14212  PyObject *error = PyErr_Occurred();
14213  if (error) {
14214  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.gmZmode'");
14215  }
14216  }
14217  int swig_val;
14218  int swig_res = SWIG_AsVal_int(result, &swig_val);
14219  if (!SWIG_IsOK(swig_res)) {
14220  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
14221  }
14222  c_result = static_cast< int >(swig_val);
14223  return (int) c_result;
14224 }
14225 
14226 
14227 void SwigDirector_SigmaProcess::setIdInDiff(int arg0, int arg1) {
14229  obj0 = SWIG_From_int(static_cast< int >(arg0));
14231  obj1 = SWIG_From_int(static_cast< int >(arg1));
14232  if (!swig_get_self()) {
14233  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
14234  }
14235 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14236  const size_t swig_method_index = 56;
14237  const char * const swig_method_name = "setIdInDiff";
14238  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14239  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
14240 #else
14241  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setIdInDiff", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
14242 #endif
14243  if (!result) {
14244  PyObject *error = PyErr_Occurred();
14245  if (error) {
14246  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.setIdInDiff'");
14247  }
14248  }
14249 }
14250 
14251 
14252 bool SwigDirector_SigmaProcess::setupForME() {
14253  bool c_result;
14254  swig_set_inner("setupForME", true);
14255  if (!swig_get_self()) {
14256  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
14257  }
14258 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14259  const size_t swig_method_index = 57;
14260  const char * const swig_method_name = "setupForME";
14261  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14262  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14263 #else
14264  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "setupForME", NULL);
14265 #endif
14266  swig_set_inner("setupForME", false);
14267  if (!result) {
14268  PyObject *error = PyErr_Occurred();
14269  if (error) {
14270  Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.setupForME'");
14271  }
14272  }
14273  bool swig_val;
14274  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14275  if (!SWIG_IsOK(swig_res)) {
14276  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14277  }
14278  c_result = static_cast< bool >(swig_val);
14279  return (bool) c_result;
14280 }
14281 
14282 
14283 SwigDirector_UserHooks::SwigDirector_UserHooks(PyObject *self): Pythia8::UserHooks(), Swig::Director(self) {
14284  SWIG_DIRECTOR_RGTR((Pythia8::UserHooks *)this, this);
14285 }
14286 
14287 
14288 
14289 
14290 SwigDirector_UserHooks::~SwigDirector_UserHooks() {
14291 }
14292 
14293 bool SwigDirector_UserHooks::initAfterBeams() {
14294  bool c_result;
14295  if (!swig_get_self()) {
14296  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14297  }
14298 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14299  const size_t swig_method_index = 0;
14300  const char * const swig_method_name = "initAfterBeams";
14301  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14302  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14303 #else
14304  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initAfterBeams", NULL);
14305 #endif
14306  if (!result) {
14307  PyObject *error = PyErr_Occurred();
14308  if (error) {
14309  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.initAfterBeams'");
14310  }
14311  }
14312  bool swig_val;
14313  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14314  if (!SWIG_IsOK(swig_res)) {
14315  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14316  }
14317  c_result = static_cast< bool >(swig_val);
14318  return (bool) c_result;
14319 }
14320 
14321 
14322 bool SwigDirector_UserHooks::canModifySigma() {
14323  bool c_result;
14324  if (!swig_get_self()) {
14325  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14326  }
14327 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14328  const size_t swig_method_index = 1;
14329  const char * const swig_method_name = "canModifySigma";
14330  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14331  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14332 #else
14333  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canModifySigma", NULL);
14334 #endif
14335  if (!result) {
14336  PyObject *error = PyErr_Occurred();
14337  if (error) {
14338  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canModifySigma'");
14339  }
14340  }
14341  bool swig_val;
14342  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14343  if (!SWIG_IsOK(swig_res)) {
14344  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14345  }
14346  c_result = static_cast< bool >(swig_val);
14347  return (bool) c_result;
14348 }
14349 
14350 
14351 double SwigDirector_UserHooks::multiplySigmaBy(Pythia8::SigmaProcess const *sigmaProcessPtr, Pythia8::PhaseSpace const *phaseSpacePtr, bool inEvent) {
14352  double c_result;
14354  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(sigmaProcessPtr), SWIGTYPE_p_Pythia8__SigmaProcess, 0 );
14356  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(phaseSpacePtr), SWIGTYPE_p_Pythia8__PhaseSpace, 0 );
14358  obj2 = SWIG_From_bool(static_cast< bool >(inEvent));
14359  if (!swig_get_self()) {
14360  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14361  }
14362 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14363  const size_t swig_method_index = 2;
14364  const char * const swig_method_name = "multiplySigmaBy";
14365  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14366  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
14367 #else
14368  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"multiplySigmaBy", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
14369 #endif
14370  if (!result) {
14371  PyObject *error = PyErr_Occurred();
14372  if (error) {
14373  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.multiplySigmaBy'");
14374  }
14375  }
14376  double swig_val;
14377  int swig_res = SWIG_AsVal_double(result, &swig_val);
14378  if (!SWIG_IsOK(swig_res)) {
14379  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
14380  }
14381  c_result = static_cast< double >(swig_val);
14382  return (double) c_result;
14383 }
14384 
14385 
14386 bool SwigDirector_UserHooks::canBiasSelection() {
14387  bool c_result;
14388  if (!swig_get_self()) {
14389  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14390  }
14391 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14392  const size_t swig_method_index = 3;
14393  const char * const swig_method_name = "canBiasSelection";
14394  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14395  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14396 #else
14397  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canBiasSelection", NULL);
14398 #endif
14399  if (!result) {
14400  PyObject *error = PyErr_Occurred();
14401  if (error) {
14402  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canBiasSelection'");
14403  }
14404  }
14405  bool swig_val;
14406  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14407  if (!SWIG_IsOK(swig_res)) {
14408  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14409  }
14410  c_result = static_cast< bool >(swig_val);
14411  return (bool) c_result;
14412 }
14413 
14414 
14415 double SwigDirector_UserHooks::biasSelectionBy(Pythia8::SigmaProcess const *sigmaProcessPtr, Pythia8::PhaseSpace const *phaseSpacePtr, bool inEvent) {
14416  double c_result;
14418  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(sigmaProcessPtr), SWIGTYPE_p_Pythia8__SigmaProcess, 0 );
14420  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(phaseSpacePtr), SWIGTYPE_p_Pythia8__PhaseSpace, 0 );
14422  obj2 = SWIG_From_bool(static_cast< bool >(inEvent));
14423  if (!swig_get_self()) {
14424  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14425  }
14426 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14427  const size_t swig_method_index = 4;
14428  const char * const swig_method_name = "biasSelectionBy";
14429  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14430  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
14431 #else
14432  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"biasSelectionBy", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
14433 #endif
14434  if (!result) {
14435  PyObject *error = PyErr_Occurred();
14436  if (error) {
14437  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.biasSelectionBy'");
14438  }
14439  }
14440  double swig_val;
14441  int swig_res = SWIG_AsVal_double(result, &swig_val);
14442  if (!SWIG_IsOK(swig_res)) {
14443  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
14444  }
14445  c_result = static_cast< double >(swig_val);
14446  return (double) c_result;
14447 }
14448 
14449 
14450 double SwigDirector_UserHooks::biasedSelectionWeight() {
14451  double c_result;
14452  if (!swig_get_self()) {
14453  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14454  }
14455 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14456  const size_t swig_method_index = 5;
14457  const char * const swig_method_name = "biasedSelectionWeight";
14458  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14459  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14460 #else
14461  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "biasedSelectionWeight", NULL);
14462 #endif
14463  if (!result) {
14464  PyObject *error = PyErr_Occurred();
14465  if (error) {
14466  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.biasedSelectionWeight'");
14467  }
14468  }
14469  double swig_val;
14470  int swig_res = SWIG_AsVal_double(result, &swig_val);
14471  if (!SWIG_IsOK(swig_res)) {
14472  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
14473  }
14474  c_result = static_cast< double >(swig_val);
14475  return (double) c_result;
14476 }
14477 
14478 
14479 bool SwigDirector_UserHooks::canVetoProcessLevel() {
14480  bool c_result;
14481  if (!swig_get_self()) {
14482  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14483  }
14484 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14485  const size_t swig_method_index = 6;
14486  const char * const swig_method_name = "canVetoProcessLevel";
14487  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14488  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14489 #else
14490  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoProcessLevel", NULL);
14491 #endif
14492  if (!result) {
14493  PyObject *error = PyErr_Occurred();
14494  if (error) {
14495  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoProcessLevel'");
14496  }
14497  }
14498  bool swig_val;
14499  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14500  if (!SWIG_IsOK(swig_res)) {
14501  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14502  }
14503  c_result = static_cast< bool >(swig_val);
14504  return (bool) c_result;
14505 }
14506 
14507 
14508 bool SwigDirector_UserHooks::doVetoProcessLevel(Pythia8::Event &arg0) {
14509  bool c_result;
14511  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
14512  if (!swig_get_self()) {
14513  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14514  }
14515 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14516  const size_t swig_method_index = 7;
14517  const char * const swig_method_name = "doVetoProcessLevel";
14518  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14519  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
14520 #else
14521  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoProcessLevel", (char *)"(O)" ,(PyObject *)obj0);
14522 #endif
14523  if (!result) {
14524  PyObject *error = PyErr_Occurred();
14525  if (error) {
14526  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoProcessLevel'");
14527  }
14528  }
14529  bool swig_val;
14530  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14531  if (!SWIG_IsOK(swig_res)) {
14532  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14533  }
14534  c_result = static_cast< bool >(swig_val);
14535  return (bool) c_result;
14536 }
14537 
14538 
14539 bool SwigDirector_UserHooks::canVetoResonanceDecays() {
14540  bool c_result;
14541  if (!swig_get_self()) {
14542  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14543  }
14544 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14545  const size_t swig_method_index = 8;
14546  const char * const swig_method_name = "canVetoResonanceDecays";
14547  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14548  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14549 #else
14550  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoResonanceDecays", NULL);
14551 #endif
14552  if (!result) {
14553  PyObject *error = PyErr_Occurred();
14554  if (error) {
14555  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoResonanceDecays'");
14556  }
14557  }
14558  bool swig_val;
14559  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14560  if (!SWIG_IsOK(swig_res)) {
14561  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14562  }
14563  c_result = static_cast< bool >(swig_val);
14564  return (bool) c_result;
14565 }
14566 
14567 
14568 bool SwigDirector_UserHooks::doVetoResonanceDecays(Pythia8::Event &arg0) {
14569  bool c_result;
14571  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
14572  if (!swig_get_self()) {
14573  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14574  }
14575 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14576  const size_t swig_method_index = 9;
14577  const char * const swig_method_name = "doVetoResonanceDecays";
14578  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14579  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
14580 #else
14581  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoResonanceDecays", (char *)"(O)" ,(PyObject *)obj0);
14582 #endif
14583  if (!result) {
14584  PyObject *error = PyErr_Occurred();
14585  if (error) {
14586  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoResonanceDecays'");
14587  }
14588  }
14589  bool swig_val;
14590  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14591  if (!SWIG_IsOK(swig_res)) {
14592  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14593  }
14594  c_result = static_cast< bool >(swig_val);
14595  return (bool) c_result;
14596 }
14597 
14598 
14599 bool SwigDirector_UserHooks::canVetoPT() {
14600  bool c_result;
14601  if (!swig_get_self()) {
14602  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14603  }
14604 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14605  const size_t swig_method_index = 10;
14606  const char * const swig_method_name = "canVetoPT";
14607  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14608  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14609 #else
14610  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoPT", NULL);
14611 #endif
14612  if (!result) {
14613  PyObject *error = PyErr_Occurred();
14614  if (error) {
14615  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoPT'");
14616  }
14617  }
14618  bool swig_val;
14619  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14620  if (!SWIG_IsOK(swig_res)) {
14621  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14622  }
14623  c_result = static_cast< bool >(swig_val);
14624  return (bool) c_result;
14625 }
14626 
14627 
14628 double SwigDirector_UserHooks::scaleVetoPT() {
14629  double c_result;
14630  if (!swig_get_self()) {
14631  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14632  }
14633 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14634  const size_t swig_method_index = 11;
14635  const char * const swig_method_name = "scaleVetoPT";
14636  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14637  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14638 #else
14639  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "scaleVetoPT", NULL);
14640 #endif
14641  if (!result) {
14642  PyObject *error = PyErr_Occurred();
14643  if (error) {
14644  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.scaleVetoPT'");
14645  }
14646  }
14647  double swig_val;
14648  int swig_res = SWIG_AsVal_double(result, &swig_val);
14649  if (!SWIG_IsOK(swig_res)) {
14650  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
14651  }
14652  c_result = static_cast< double >(swig_val);
14653  return (double) c_result;
14654 }
14655 
14656 
14657 bool SwigDirector_UserHooks::doVetoPT(int arg0, Pythia8::Event const &arg1) {
14658  bool c_result;
14660  obj0 = SWIG_From_int(static_cast< int >(arg0));
14662  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
14663  if (!swig_get_self()) {
14664  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14665  }
14666 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14667  const size_t swig_method_index = 12;
14668  const char * const swig_method_name = "doVetoPT";
14669  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14670  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
14671 #else
14672  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoPT", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
14673 #endif
14674  if (!result) {
14675  PyObject *error = PyErr_Occurred();
14676  if (error) {
14677  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoPT'");
14678  }
14679  }
14680  bool swig_val;
14681  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14682  if (!SWIG_IsOK(swig_res)) {
14683  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14684  }
14685  c_result = static_cast< bool >(swig_val);
14686  return (bool) c_result;
14687 }
14688 
14689 
14690 bool SwigDirector_UserHooks::canVetoStep() {
14691  bool c_result;
14692  if (!swig_get_self()) {
14693  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14694  }
14695 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14696  const size_t swig_method_index = 13;
14697  const char * const swig_method_name = "canVetoStep";
14698  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14699  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14700 #else
14701  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoStep", NULL);
14702 #endif
14703  if (!result) {
14704  PyObject *error = PyErr_Occurred();
14705  if (error) {
14706  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoStep'");
14707  }
14708  }
14709  bool swig_val;
14710  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14711  if (!SWIG_IsOK(swig_res)) {
14712  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14713  }
14714  c_result = static_cast< bool >(swig_val);
14715  return (bool) c_result;
14716 }
14717 
14718 
14719 int SwigDirector_UserHooks::numberVetoStep() {
14720  int c_result;
14721  if (!swig_get_self()) {
14722  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14723  }
14724 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14725  const size_t swig_method_index = 14;
14726  const char * const swig_method_name = "numberVetoStep";
14727  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14728  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14729 #else
14730  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "numberVetoStep", NULL);
14731 #endif
14732  if (!result) {
14733  PyObject *error = PyErr_Occurred();
14734  if (error) {
14735  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.numberVetoStep'");
14736  }
14737  }
14738  int swig_val;
14739  int swig_res = SWIG_AsVal_int(result, &swig_val);
14740  if (!SWIG_IsOK(swig_res)) {
14741  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
14742  }
14743  c_result = static_cast< int >(swig_val);
14744  return (int) c_result;
14745 }
14746 
14747 
14748 bool SwigDirector_UserHooks::doVetoStep(int arg0, int arg1, int arg2, Pythia8::Event const &arg3) {
14749  bool c_result;
14751  obj0 = SWIG_From_int(static_cast< int >(arg0));
14753  obj1 = SWIG_From_int(static_cast< int >(arg1));
14755  obj2 = SWIG_From_int(static_cast< int >(arg2));
14757  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg3), SWIGTYPE_p_Pythia8__Event, 0 );
14758  if (!swig_get_self()) {
14759  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14760  }
14761 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14762  const size_t swig_method_index = 15;
14763  const char * const swig_method_name = "doVetoStep";
14764  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14765  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
14766 #else
14767  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoStep", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
14768 #endif
14769  if (!result) {
14770  PyObject *error = PyErr_Occurred();
14771  if (error) {
14772  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoStep'");
14773  }
14774  }
14775  bool swig_val;
14776  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14777  if (!SWIG_IsOK(swig_res)) {
14778  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14779  }
14780  c_result = static_cast< bool >(swig_val);
14781  return (bool) c_result;
14782 }
14783 
14784 
14785 bool SwigDirector_UserHooks::canVetoMPIStep() {
14786  bool c_result;
14787  if (!swig_get_self()) {
14788  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14789  }
14790 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14791  const size_t swig_method_index = 16;
14792  const char * const swig_method_name = "canVetoMPIStep";
14793  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14794  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14795 #else
14796  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoMPIStep", NULL);
14797 #endif
14798  if (!result) {
14799  PyObject *error = PyErr_Occurred();
14800  if (error) {
14801  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoMPIStep'");
14802  }
14803  }
14804  bool swig_val;
14805  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14806  if (!SWIG_IsOK(swig_res)) {
14807  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14808  }
14809  c_result = static_cast< bool >(swig_val);
14810  return (bool) c_result;
14811 }
14812 
14813 
14814 int SwigDirector_UserHooks::numberVetoMPIStep() {
14815  int c_result;
14816  if (!swig_get_self()) {
14817  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14818  }
14819 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14820  const size_t swig_method_index = 17;
14821  const char * const swig_method_name = "numberVetoMPIStep";
14822  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14823  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14824 #else
14825  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "numberVetoMPIStep", NULL);
14826 #endif
14827  if (!result) {
14828  PyObject *error = PyErr_Occurred();
14829  if (error) {
14830  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.numberVetoMPIStep'");
14831  }
14832  }
14833  int swig_val;
14834  int swig_res = SWIG_AsVal_int(result, &swig_val);
14835  if (!SWIG_IsOK(swig_res)) {
14836  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
14837  }
14838  c_result = static_cast< int >(swig_val);
14839  return (int) c_result;
14840 }
14841 
14842 
14843 bool SwigDirector_UserHooks::doVetoMPIStep(int arg0, Pythia8::Event const &arg1) {
14844  bool c_result;
14846  obj0 = SWIG_From_int(static_cast< int >(arg0));
14848  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
14849  if (!swig_get_self()) {
14850  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14851  }
14852 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14853  const size_t swig_method_index = 18;
14854  const char * const swig_method_name = "doVetoMPIStep";
14855  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14856  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
14857 #else
14858  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoMPIStep", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
14859 #endif
14860  if (!result) {
14861  PyObject *error = PyErr_Occurred();
14862  if (error) {
14863  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoMPIStep'");
14864  }
14865  }
14866  bool swig_val;
14867  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14868  if (!SWIG_IsOK(swig_res)) {
14869  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14870  }
14871  c_result = static_cast< bool >(swig_val);
14872  return (bool) c_result;
14873 }
14874 
14875 
14876 bool SwigDirector_UserHooks::canVetoPartonLevelEarly() {
14877  bool c_result;
14878  if (!swig_get_self()) {
14879  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14880  }
14881 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14882  const size_t swig_method_index = 19;
14883  const char * const swig_method_name = "canVetoPartonLevelEarly";
14884  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14885  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14886 #else
14887  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoPartonLevelEarly", NULL);
14888 #endif
14889  if (!result) {
14890  PyObject *error = PyErr_Occurred();
14891  if (error) {
14892  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoPartonLevelEarly'");
14893  }
14894  }
14895  bool swig_val;
14896  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14897  if (!SWIG_IsOK(swig_res)) {
14898  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14899  }
14900  c_result = static_cast< bool >(swig_val);
14901  return (bool) c_result;
14902 }
14903 
14904 
14905 bool SwigDirector_UserHooks::doVetoPartonLevelEarly(Pythia8::Event const &arg0) {
14906  bool c_result;
14908  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
14909  if (!swig_get_self()) {
14910  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14911  }
14912 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14913  const size_t swig_method_index = 20;
14914  const char * const swig_method_name = "doVetoPartonLevelEarly";
14915  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14916  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
14917 #else
14918  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoPartonLevelEarly", (char *)"(O)" ,(PyObject *)obj0);
14919 #endif
14920  if (!result) {
14921  PyObject *error = PyErr_Occurred();
14922  if (error) {
14923  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoPartonLevelEarly'");
14924  }
14925  }
14926  bool swig_val;
14927  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14928  if (!SWIG_IsOK(swig_res)) {
14929  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14930  }
14931  c_result = static_cast< bool >(swig_val);
14932  return (bool) c_result;
14933 }
14934 
14935 
14936 bool SwigDirector_UserHooks::retryPartonLevel() {
14937  bool c_result;
14938  if (!swig_get_self()) {
14939  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14940  }
14941 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14942  const size_t swig_method_index = 21;
14943  const char * const swig_method_name = "retryPartonLevel";
14944  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14945  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14946 #else
14947  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "retryPartonLevel", NULL);
14948 #endif
14949  if (!result) {
14950  PyObject *error = PyErr_Occurred();
14951  if (error) {
14952  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.retryPartonLevel'");
14953  }
14954  }
14955  bool swig_val;
14956  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14957  if (!SWIG_IsOK(swig_res)) {
14958  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14959  }
14960  c_result = static_cast< bool >(swig_val);
14961  return (bool) c_result;
14962 }
14963 
14964 
14965 bool SwigDirector_UserHooks::canVetoPartonLevel() {
14966  bool c_result;
14967  if (!swig_get_self()) {
14968  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
14969  }
14970 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
14971  const size_t swig_method_index = 22;
14972  const char * const swig_method_name = "canVetoPartonLevel";
14973  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
14974  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
14975 #else
14976  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoPartonLevel", NULL);
14977 #endif
14978  if (!result) {
14979  PyObject *error = PyErr_Occurred();
14980  if (error) {
14981  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoPartonLevel'");
14982  }
14983  }
14984  bool swig_val;
14985  int swig_res = SWIG_AsVal_bool(result, &swig_val);
14986  if (!SWIG_IsOK(swig_res)) {
14987  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
14988  }
14989  c_result = static_cast< bool >(swig_val);
14990  return (bool) c_result;
14991 }
14992 
14993 
14994 bool SwigDirector_UserHooks::doVetoPartonLevel(Pythia8::Event const &arg0) {
14995  bool c_result;
14997  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
14998  if (!swig_get_self()) {
14999  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15000  }
15001 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15002  const size_t swig_method_index = 23;
15003  const char * const swig_method_name = "doVetoPartonLevel";
15004  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15005  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
15006 #else
15007  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoPartonLevel", (char *)"(O)" ,(PyObject *)obj0);
15008 #endif
15009  if (!result) {
15010  PyObject *error = PyErr_Occurred();
15011  if (error) {
15012  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoPartonLevel'");
15013  }
15014  }
15015  bool swig_val;
15016  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15017  if (!SWIG_IsOK(swig_res)) {
15018  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15019  }
15020  c_result = static_cast< bool >(swig_val);
15021  return (bool) c_result;
15022 }
15023 
15024 
15025 bool SwigDirector_UserHooks::canSetResonanceScale() {
15026  bool c_result;
15027  if (!swig_get_self()) {
15028  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15029  }
15030 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15031  const size_t swig_method_index = 24;
15032  const char * const swig_method_name = "canSetResonanceScale";
15033  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15034  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15035 #else
15036  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canSetResonanceScale", NULL);
15037 #endif
15038  if (!result) {
15039  PyObject *error = PyErr_Occurred();
15040  if (error) {
15041  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canSetResonanceScale'");
15042  }
15043  }
15044  bool swig_val;
15045  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15046  if (!SWIG_IsOK(swig_res)) {
15047  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15048  }
15049  c_result = static_cast< bool >(swig_val);
15050  return (bool) c_result;
15051 }
15052 
15053 
15054 double SwigDirector_UserHooks::scaleResonance(int arg0, Pythia8::Event const &arg1) {
15055  double c_result;
15057  obj0 = SWIG_From_int(static_cast< int >(arg0));
15059  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
15060  if (!swig_get_self()) {
15061  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15062  }
15063 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15064  const size_t swig_method_index = 25;
15065  const char * const swig_method_name = "scaleResonance";
15066  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15067  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15068 #else
15069  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"scaleResonance", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15070 #endif
15071  if (!result) {
15072  PyObject *error = PyErr_Occurred();
15073  if (error) {
15074  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.scaleResonance'");
15075  }
15076  }
15077  double swig_val;
15078  int swig_res = SWIG_AsVal_double(result, &swig_val);
15079  if (!SWIG_IsOK(swig_res)) {
15080  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
15081  }
15082  c_result = static_cast< double >(swig_val);
15083  return (double) c_result;
15084 }
15085 
15086 
15087 bool SwigDirector_UserHooks::canVetoISREmission() {
15088  bool c_result;
15089  if (!swig_get_self()) {
15090  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15091  }
15092 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15093  const size_t swig_method_index = 26;
15094  const char * const swig_method_name = "canVetoISREmission";
15095  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15096  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15097 #else
15098  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoISREmission", NULL);
15099 #endif
15100  if (!result) {
15101  PyObject *error = PyErr_Occurred();
15102  if (error) {
15103  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoISREmission'");
15104  }
15105  }
15106  bool swig_val;
15107  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15108  if (!SWIG_IsOK(swig_res)) {
15109  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15110  }
15111  c_result = static_cast< bool >(swig_val);
15112  return (bool) c_result;
15113 }
15114 
15115 
15116 bool SwigDirector_UserHooks::doVetoISREmission(int arg0, Pythia8::Event const &arg1, int arg2) {
15117  bool c_result;
15119  obj0 = SWIG_From_int(static_cast< int >(arg0));
15121  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
15123  obj2 = SWIG_From_int(static_cast< int >(arg2));
15124  if (!swig_get_self()) {
15125  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15126  }
15127 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15128  const size_t swig_method_index = 27;
15129  const char * const swig_method_name = "doVetoISREmission";
15130  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15131  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
15132 #else
15133  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoISREmission", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
15134 #endif
15135  if (!result) {
15136  PyObject *error = PyErr_Occurred();
15137  if (error) {
15138  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoISREmission'");
15139  }
15140  }
15141  bool swig_val;
15142  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15143  if (!SWIG_IsOK(swig_res)) {
15144  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15145  }
15146  c_result = static_cast< bool >(swig_val);
15147  return (bool) c_result;
15148 }
15149 
15150 
15151 bool SwigDirector_UserHooks::canVetoFSREmission() {
15152  bool c_result;
15153  if (!swig_get_self()) {
15154  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15155  }
15156 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15157  const size_t swig_method_index = 28;
15158  const char * const swig_method_name = "canVetoFSREmission";
15159  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15160  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15161 #else
15162  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoFSREmission", NULL);
15163 #endif
15164  if (!result) {
15165  PyObject *error = PyErr_Occurred();
15166  if (error) {
15167  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoFSREmission'");
15168  }
15169  }
15170  bool swig_val;
15171  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15172  if (!SWIG_IsOK(swig_res)) {
15173  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15174  }
15175  c_result = static_cast< bool >(swig_val);
15176  return (bool) c_result;
15177 }
15178 
15179 
15180 bool SwigDirector_UserHooks::doVetoFSREmission(int arg0, Pythia8::Event const &arg1, int arg2, bool arg3) {
15181  bool c_result;
15183  obj0 = SWIG_From_int(static_cast< int >(arg0));
15185  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
15187  obj2 = SWIG_From_int(static_cast< int >(arg2));
15189  obj3 = SWIG_From_bool(static_cast< bool >(arg3));
15190  if (!swig_get_self()) {
15191  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15192  }
15193 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15194  const size_t swig_method_index = 29;
15195  const char * const swig_method_name = "doVetoFSREmission";
15196  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15197  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
15198 #else
15199  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoFSREmission", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
15200 #endif
15201  if (!result) {
15202  PyObject *error = PyErr_Occurred();
15203  if (error) {
15204  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoFSREmission'");
15205  }
15206  }
15207  bool swig_val;
15208  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15209  if (!SWIG_IsOK(swig_res)) {
15210  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15211  }
15212  c_result = static_cast< bool >(swig_val);
15213  return (bool) c_result;
15214 }
15215 
15216 
15217 bool SwigDirector_UserHooks::canVetoMPIEmission() {
15218  bool c_result;
15219  if (!swig_get_self()) {
15220  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15221  }
15222 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15223  const size_t swig_method_index = 31;
15224  const char * const swig_method_name = "canVetoMPIEmission";
15225  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15226  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15227 #else
15228  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoMPIEmission", NULL);
15229 #endif
15230  if (!result) {
15231  PyObject *error = PyErr_Occurred();
15232  if (error) {
15233  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoMPIEmission'");
15234  }
15235  }
15236  bool swig_val;
15237  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15238  if (!SWIG_IsOK(swig_res)) {
15239  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15240  }
15241  c_result = static_cast< bool >(swig_val);
15242  return (bool) c_result;
15243 }
15244 
15245 
15246 bool SwigDirector_UserHooks::doVetoMPIEmission(int arg0, Pythia8::Event const &arg1) {
15247  bool c_result;
15249  obj0 = SWIG_From_int(static_cast< int >(arg0));
15251  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
15252  if (!swig_get_self()) {
15253  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15254  }
15255 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15256  const size_t swig_method_index = 32;
15257  const char * const swig_method_name = "doVetoMPIEmission";
15258  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15259  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15260 #else
15261  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoMPIEmission", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15262 #endif
15263  if (!result) {
15264  PyObject *error = PyErr_Occurred();
15265  if (error) {
15266  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoMPIEmission'");
15267  }
15268  }
15269  bool swig_val;
15270  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15271  if (!SWIG_IsOK(swig_res)) {
15272  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15273  }
15274  c_result = static_cast< bool >(swig_val);
15275  return (bool) c_result;
15276 }
15277 
15278 
15279 bool SwigDirector_UserHooks::canReconnectResonanceSystems() {
15280  bool c_result;
15281  if (!swig_get_self()) {
15282  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15283  }
15284 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15285  const size_t swig_method_index = 33;
15286  const char * const swig_method_name = "canReconnectResonanceSystems";
15287  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15288  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15289 #else
15290  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canReconnectResonanceSystems", NULL);
15291 #endif
15292  if (!result) {
15293  PyObject *error = PyErr_Occurred();
15294  if (error) {
15295  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canReconnectResonanceSystems'");
15296  }
15297  }
15298  bool swig_val;
15299  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15300  if (!SWIG_IsOK(swig_res)) {
15301  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15302  }
15303  c_result = static_cast< bool >(swig_val);
15304  return (bool) c_result;
15305 }
15306 
15307 
15308 bool SwigDirector_UserHooks::doReconnectResonanceSystems(int arg0, Pythia8::Event &arg1) {
15309  bool c_result;
15311  obj0 = SWIG_From_int(static_cast< int >(arg0));
15313  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
15314  if (!swig_get_self()) {
15315  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15316  }
15317 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15318  const size_t swig_method_index = 34;
15319  const char * const swig_method_name = "doReconnectResonanceSystems";
15320  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15321  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15322 #else
15323  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doReconnectResonanceSystems", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15324 #endif
15325  if (!result) {
15326  PyObject *error = PyErr_Occurred();
15327  if (error) {
15328  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doReconnectResonanceSystems'");
15329  }
15330  }
15331  bool swig_val;
15332  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15333  if (!SWIG_IsOK(swig_res)) {
15334  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15335  }
15336  c_result = static_cast< bool >(swig_val);
15337  return (bool) c_result;
15338 }
15339 
15340 
15341 bool SwigDirector_UserHooks::canEnhanceEmission() {
15342  bool c_result;
15343  if (!swig_get_self()) {
15344  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15345  }
15346 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15347  const size_t swig_method_index = 35;
15348  const char * const swig_method_name = "canEnhanceEmission";
15349  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15350  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15351 #else
15352  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canEnhanceEmission", NULL);
15353 #endif
15354  if (!result) {
15355  PyObject *error = PyErr_Occurred();
15356  if (error) {
15357  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canEnhanceEmission'");
15358  }
15359  }
15360  bool swig_val;
15361  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15362  if (!SWIG_IsOK(swig_res)) {
15363  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15364  }
15365  c_result = static_cast< bool >(swig_val);
15366  return (bool) c_result;
15367 }
15368 
15369 
15370 double SwigDirector_UserHooks::enhanceFactor(std::string arg0) {
15371  double c_result;
15373  obj0 = SWIG_From_std_string(static_cast< std::string >(arg0));
15374  if (!swig_get_self()) {
15375  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15376  }
15377 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15378  const size_t swig_method_index = 36;
15379  const char * const swig_method_name = "enhanceFactor";
15380  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15381  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
15382 #else
15383  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"enhanceFactor", (char *)"(O)" ,(PyObject *)obj0);
15384 #endif
15385  if (!result) {
15386  PyObject *error = PyErr_Occurred();
15387  if (error) {
15388  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.enhanceFactor'");
15389  }
15390  }
15391  double swig_val;
15392  int swig_res = SWIG_AsVal_double(result, &swig_val);
15393  if (!SWIG_IsOK(swig_res)) {
15394  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
15395  }
15396  c_result = static_cast< double >(swig_val);
15397  return (double) c_result;
15398 }
15399 
15400 
15401 double SwigDirector_UserHooks::vetoProbability(std::string arg0) {
15402  double c_result;
15404  obj0 = SWIG_From_std_string(static_cast< std::string >(arg0));
15405  if (!swig_get_self()) {
15406  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15407  }
15408 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15409  const size_t swig_method_index = 37;
15410  const char * const swig_method_name = "vetoProbability";
15411  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15412  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
15413 #else
15414  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"vetoProbability", (char *)"(O)" ,(PyObject *)obj0);
15415 #endif
15416  if (!result) {
15417  PyObject *error = PyErr_Occurred();
15418  if (error) {
15419  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.vetoProbability'");
15420  }
15421  }
15422  double swig_val;
15423  int swig_res = SWIG_AsVal_double(result, &swig_val);
15424  if (!SWIG_IsOK(swig_res)) {
15425  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
15426  }
15427  c_result = static_cast< double >(swig_val);
15428  return (double) c_result;
15429 }
15430 
15431 
15432 bool SwigDirector_UserHooks::canEnhanceTrial() {
15433  bool c_result;
15434  if (!swig_get_self()) {
15435  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15436  }
15437 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15438  const size_t swig_method_index = 38;
15439  const char * const swig_method_name = "canEnhanceTrial";
15440  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15441  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15442 #else
15443  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canEnhanceTrial", NULL);
15444 #endif
15445  if (!result) {
15446  PyObject *error = PyErr_Occurred();
15447  if (error) {
15448  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canEnhanceTrial'");
15449  }
15450  }
15451  bool swig_val;
15452  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15453  if (!SWIG_IsOK(swig_res)) {
15454  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15455  }
15456  c_result = static_cast< bool >(swig_val);
15457  return (bool) c_result;
15458 }
15459 
15460 
15461 bool SwigDirector_UserHooks::canChangeFragPar() {
15462  bool c_result;
15463  if (!swig_get_self()) {
15464  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15465  }
15466 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15467  const size_t swig_method_index = 39;
15468  const char * const swig_method_name = "canChangeFragPar";
15469  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15470  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15471 #else
15472  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canChangeFragPar", NULL);
15473 #endif
15474  if (!result) {
15475  PyObject *error = PyErr_Occurred();
15476  if (error) {
15477  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canChangeFragPar'");
15478  }
15479  }
15480  bool swig_val;
15481  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15482  if (!SWIG_IsOK(swig_res)) {
15483  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15484  }
15485  c_result = static_cast< bool >(swig_val);
15486  return (bool) c_result;
15487 }
15488 
15489 
15490 void SwigDirector_UserHooks::setStringEnds(Pythia8::StringEnd const *arg0, Pythia8::StringEnd const *arg1, std::vector< int,std::allocator< int > > arg2) {
15492  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_Pythia8__StringEnd, 0 );
15494  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(arg1), SWIGTYPE_p_Pythia8__StringEnd, 0 );
15496  obj2 = swig::from(static_cast< std::vector< int,std::allocator< int > > >(arg2));
15497  if (!swig_get_self()) {
15498  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15499  }
15500 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15501  const size_t swig_method_index = 40;
15502  const char * const swig_method_name = "setStringEnds";
15503  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15504  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
15505 #else
15506  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setStringEnds", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
15507 #endif
15508  if (!result) {
15509  PyObject *error = PyErr_Occurred();
15510  if (error) {
15511  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.setStringEnds'");
15512  }
15513  }
15514 }
15515 
15516 
15517 bool SwigDirector_UserHooks::doChangeFragPar(Pythia8::StringFlav *arg0, Pythia8::StringZ *arg1, Pythia8::StringPT *arg2, int arg3, double arg4, std::vector< int,std::allocator< int > > arg5, Pythia8::StringEnd const *arg6) {
15518  bool c_result;
15520  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_Pythia8__StringFlav, 0 );
15522  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(arg1), SWIGTYPE_p_Pythia8__StringZ, 0 );
15524  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(arg2), SWIGTYPE_p_Pythia8__StringPT, 0 );
15526  obj3 = SWIG_From_int(static_cast< int >(arg3));
15528  obj4 = SWIG_From_double(static_cast< double >(arg4));
15530  obj5 = swig::from(static_cast< std::vector< int,std::allocator< int > > >(arg5));
15532  obj6 = SWIG_NewPointerObj(SWIG_as_voidptr(arg6), SWIGTYPE_p_Pythia8__StringEnd, 0 );
15533  if (!swig_get_self()) {
15534  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15535  }
15536 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15537  const size_t swig_method_index = 41;
15538  const char * const swig_method_name = "doChangeFragPar";
15539  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15540  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6);
15541 #else
15542  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doChangeFragPar", (char *)"(OOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6);
15543 #endif
15544  if (!result) {
15545  PyObject *error = PyErr_Occurred();
15546  if (error) {
15547  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doChangeFragPar'");
15548  }
15549  }
15550  bool swig_val;
15551  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15552  if (!SWIG_IsOK(swig_res)) {
15553  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15554  }
15555  c_result = static_cast< bool >(swig_val);
15556  return (bool) c_result;
15557 }
15558 
15559 
15560 bool SwigDirector_UserHooks::doVetoFragmentation(Pythia8::Particle arg0, Pythia8::StringEnd const *arg1) {
15561  bool c_result;
15563  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Particle, 0 );
15565  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(arg1), SWIGTYPE_p_Pythia8__StringEnd, 0 );
15566  if (!swig_get_self()) {
15567  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15568  }
15569 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15570  const size_t swig_method_index = 42;
15571  const char * const swig_method_name = "doVetoFragmentation";
15572  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15573  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15574 #else
15575  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoFragmentation", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15576 #endif
15577  if (!result) {
15578  PyObject *error = PyErr_Occurred();
15579  if (error) {
15580  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoFragmentation'");
15581  }
15582  }
15583  bool swig_val;
15584  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15585  if (!SWIG_IsOK(swig_res)) {
15586  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15587  }
15588  c_result = static_cast< bool >(swig_val);
15589  return (bool) c_result;
15590 }
15591 
15592 
15593 bool SwigDirector_UserHooks::doVetoFragmentation(Pythia8::Particle arg0, Pythia8::Particle arg1, Pythia8::StringEnd const *arg2, Pythia8::StringEnd const *arg3) {
15594  bool c_result;
15596  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Particle, 0 );
15598  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Particle, 0 );
15600  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(arg2), SWIGTYPE_p_Pythia8__StringEnd, 0 );
15602  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(arg3), SWIGTYPE_p_Pythia8__StringEnd, 0 );
15603  if (!swig_get_self()) {
15604  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15605  }
15606 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15607  const size_t swig_method_index = 43;
15608  const char * const swig_method_name = "doVetoFragmentation";
15609  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15610  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
15611 #else
15612  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoFragmentation", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
15613 #endif
15614  if (!result) {
15615  PyObject *error = PyErr_Occurred();
15616  if (error) {
15617  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoFragmentation'");
15618  }
15619  }
15620  bool swig_val;
15621  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15622  if (!SWIG_IsOK(swig_res)) {
15623  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15624  }
15625  c_result = static_cast< bool >(swig_val);
15626  return (bool) c_result;
15627 }
15628 
15629 
15630 bool SwigDirector_UserHooks::canSetImpactParameter() const {
15631  bool c_result;
15632  if (!swig_get_self()) {
15633  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15634  }
15635 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15636  const size_t swig_method_index = 44;
15637  const char * const swig_method_name = "canSetImpactParameter";
15638  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15639  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15640 #else
15641  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canSetImpactParameter", NULL);
15642 #endif
15643  if (!result) {
15644  PyObject *error = PyErr_Occurred();
15645  if (error) {
15646  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canSetImpactParameter'");
15647  }
15648  }
15649  bool swig_val;
15650  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15651  if (!SWIG_IsOK(swig_res)) {
15652  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15653  }
15654  c_result = static_cast< bool >(swig_val);
15655  return (bool) c_result;
15656 }
15657 
15658 
15659 double SwigDirector_UserHooks::doSetImpactParameter() {
15660  double c_result;
15661  if (!swig_get_self()) {
15662  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
15663  }
15664 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15665  const size_t swig_method_index = 45;
15666  const char * const swig_method_name = "doSetImpactParameter";
15667  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15668  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15669 #else
15670  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "doSetImpactParameter", NULL);
15671 #endif
15672  if (!result) {
15673  PyObject *error = PyErr_Occurred();
15674  if (error) {
15675  Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doSetImpactParameter'");
15676  }
15677  }
15678  double swig_val;
15679  int swig_res = SWIG_AsVal_double(result, &swig_val);
15680  if (!SWIG_IsOK(swig_res)) {
15681  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
15682  }
15683  c_result = static_cast< double >(swig_val);
15684  return (double) c_result;
15685 }
15686 
15687 
15688 SwigDirector_PhaseSpace::SwigDirector_PhaseSpace(PyObject *self): Pythia8::PhaseSpace(), Swig::Director(self) {
15689  SWIG_DIRECTOR_RGTR((Pythia8::PhaseSpace *)this, this);
15690 }
15691 
15692 
15693 
15694 
15695 SwigDirector_PhaseSpace::~SwigDirector_PhaseSpace() {
15696 }
15697 
15698 bool SwigDirector_PhaseSpace::setupSampling() {
15699  bool c_result;
15700  if (!swig_get_self()) {
15701  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
15702  }
15703 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15704  const size_t swig_method_index = 0;
15705  const char * const swig_method_name = "setupSampling";
15706  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15707  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15708 #else
15709  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "setupSampling", NULL);
15710 #endif
15711  if (!result) {
15712  PyObject *error = PyErr_Occurred();
15713  if (error) {
15714  Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.setupSampling'");
15715  }
15716  }
15717  bool swig_val;
15718  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15719  if (!SWIG_IsOK(swig_res)) {
15720  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15721  }
15722  c_result = static_cast< bool >(swig_val);
15723  return (bool) c_result;
15724 }
15725 
15726 
15727 bool SwigDirector_PhaseSpace::trialKin(bool inEvent, bool repeatSame) {
15728  bool c_result;
15730  obj0 = SWIG_From_bool(static_cast< bool >(inEvent));
15732  obj1 = SWIG_From_bool(static_cast< bool >(repeatSame));
15733  if (!swig_get_self()) {
15734  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
15735  }
15736 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15737  const size_t swig_method_index = 1;
15738  const char * const swig_method_name = "trialKin";
15739  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15740  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15741 #else
15742  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"trialKin", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15743 #endif
15744  if (!result) {
15745  PyObject *error = PyErr_Occurred();
15746  if (error) {
15747  Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.trialKin'");
15748  }
15749  }
15750  bool swig_val;
15751  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15752  if (!SWIG_IsOK(swig_res)) {
15753  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15754  }
15755  c_result = static_cast< bool >(swig_val);
15756  return (bool) c_result;
15757 }
15758 
15759 
15760 bool SwigDirector_PhaseSpace::finalKin() {
15761  bool c_result;
15762  if (!swig_get_self()) {
15763  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
15764  }
15765 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15766  const size_t swig_method_index = 4;
15767  const char * const swig_method_name = "finalKin";
15768  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15769  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15770 #else
15771  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "finalKin", NULL);
15772 #endif
15773  if (!result) {
15774  PyObject *error = PyErr_Occurred();
15775  if (error) {
15776  Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.finalKin'");
15777  }
15778  }
15779  bool swig_val;
15780  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15781  if (!SWIG_IsOK(swig_res)) {
15782  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15783  }
15784  c_result = static_cast< bool >(swig_val);
15785  return (bool) c_result;
15786 }
15787 
15788 
15789 double SwigDirector_PhaseSpace::sigmaSumSigned() const {
15790  double c_result;
15791  if (!swig_get_self()) {
15792  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
15793  }
15794 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15795  const size_t swig_method_index = 5;
15796  const char * const swig_method_name = "sigmaSumSigned";
15797  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15798  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15799 #else
15800  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "sigmaSumSigned", NULL);
15801 #endif
15802  if (!result) {
15803  PyObject *error = PyErr_Occurred();
15804  if (error) {
15805  Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.sigmaSumSigned'");
15806  }
15807  }
15808  double swig_val;
15809  int swig_res = SWIG_AsVal_double(result, &swig_val);
15810  if (!SWIG_IsOK(swig_res)) {
15811  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
15812  }
15813  c_result = static_cast< double >(swig_val);
15814  return (double) c_result;
15815 }
15816 
15817 
15818 bool SwigDirector_PhaseSpace::isResolved() const {
15819  bool c_result;
15820  if (!swig_get_self()) {
15821  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
15822  }
15823 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15824  const size_t swig_method_index = 6;
15825  const char * const swig_method_name = "isResolved";
15826  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15827  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15828 #else
15829  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isResolved", NULL);
15830 #endif
15831  if (!result) {
15832  PyObject *error = PyErr_Occurred();
15833  if (error) {
15834  Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.isResolved'");
15835  }
15836  }
15837  bool swig_val;
15838  int swig_res = SWIG_AsVal_bool(result, &swig_val);
15839  if (!SWIG_IsOK(swig_res)) {
15840  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
15841  }
15842  c_result = static_cast< bool >(swig_val);
15843  return (bool) c_result;
15844 }
15845 
15846 
15847 void SwigDirector_PhaseSpace::rescaleSigma(double arg0) {
15849  obj0 = SWIG_From_double(static_cast< double >(arg0));
15850  if (!swig_get_self()) {
15851  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
15852  }
15853 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15854  const size_t swig_method_index = 7;
15855  const char * const swig_method_name = "rescaleSigma";
15856  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15857  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
15858 #else
15859  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"rescaleSigma", (char *)"(O)" ,(PyObject *)obj0);
15860 #endif
15861  if (!result) {
15862  PyObject *error = PyErr_Occurred();
15863  if (error) {
15864  Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.rescaleSigma'");
15865  }
15866  }
15867 }
15868 
15869 
15870 void SwigDirector_PhaseSpace::rescaleMomenta(double arg0) {
15872  obj0 = SWIG_From_double(static_cast< double >(arg0));
15873  if (!swig_get_self()) {
15874  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
15875  }
15876 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15877  const size_t swig_method_index = 8;
15878  const char * const swig_method_name = "rescaleMomenta";
15879  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15880  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
15881 #else
15882  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"rescaleMomenta", (char *)"(O)" ,(PyObject *)obj0);
15883 #endif
15884  if (!result) {
15885  PyObject *error = PyErr_Occurred();
15886  if (error) {
15887  Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.rescaleMomenta'");
15888  }
15889  }
15890 }
15891 
15892 
15893 double SwigDirector_PhaseSpace::weightGammaPDFApprox() {
15894  double c_result;
15895  if (!swig_get_self()) {
15896  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
15897  }
15898 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15899  const size_t swig_method_index = 9;
15900  const char * const swig_method_name = "weightGammaPDFApprox";
15901  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15902  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
15903 #else
15904  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "weightGammaPDFApprox", NULL);
15905 #endif
15906  if (!result) {
15907  PyObject *error = PyErr_Occurred();
15908  if (error) {
15909  Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.weightGammaPDFApprox'");
15910  }
15911  }
15912  double swig_val;
15913  int swig_res = SWIG_AsVal_double(result, &swig_val);
15914  if (!SWIG_IsOK(swig_res)) {
15915  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
15916  }
15917  c_result = static_cast< double >(swig_val);
15918  return (double) c_result;
15919 }
15920 
15921 
15922 void SwigDirector_PhaseSpace::setGammaKinPtr(Pythia8::GammaKinematics *gammaKinPtrIn) {
15924  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(gammaKinPtrIn), SWIGTYPE_p_Pythia8__GammaKinematics, 0 );
15925  if (!swig_get_self()) {
15926  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
15927  }
15928 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15929  const size_t swig_method_index = 10;
15930  const char * const swig_method_name = "setGammaKinPtr";
15931  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15932  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
15933 #else
15934  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setGammaKinPtr", (char *)"(O)" ,(PyObject *)obj0);
15935 #endif
15936  if (!result) {
15937  PyObject *error = PyErr_Occurred();
15938  if (error) {
15939  Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.setGammaKinPtr'");
15940  }
15941  }
15942 }
15943 
15944 
15945 SwigDirector_SpaceShower::SwigDirector_SpaceShower(PyObject *self): Pythia8::SpaceShower(), Swig::Director(self) {
15946  SWIG_DIRECTOR_RGTR((Pythia8::SpaceShower *)this, this);
15947 }
15948 
15949 
15950 
15951 
15952 SwigDirector_SpaceShower::~SwigDirector_SpaceShower() {
15953 }
15954 
15955 void SwigDirector_SpaceShower::init(Pythia8::BeamParticle *arg0, Pythia8::BeamParticle *arg1) {
15957  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_Pythia8__BeamParticle, 0 );
15959  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(arg1), SWIGTYPE_p_Pythia8__BeamParticle, 0 );
15960  if (!swig_get_self()) {
15961  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
15962  }
15963 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15964  const size_t swig_method_index = 0;
15965  const char * const swig_method_name = "init";
15966  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15967  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15968 #else
15969  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"init", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
15970 #endif
15971  if (!result) {
15972  PyObject *error = PyErr_Occurred();
15973  if (error) {
15974  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.init'");
15975  }
15976  }
15977 }
15978 
15979 
15980 bool SwigDirector_SpaceShower::limitPTmax(Pythia8::Event &arg0, double arg1, double arg2) {
15981  bool c_result;
15983  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
15985  obj1 = SWIG_From_double(static_cast< double >(arg1));
15987  obj2 = SWIG_From_double(static_cast< double >(arg2));
15988  if (!swig_get_self()) {
15989  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
15990  }
15991 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
15992  const size_t swig_method_index = 1;
15993  const char * const swig_method_name = "limitPTmax";
15994  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
15995  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
15996 #else
15997  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"limitPTmax", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
15998 #endif
15999  if (!result) {
16000  PyObject *error = PyErr_Occurred();
16001  if (error) {
16002  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.limitPTmax'");
16003  }
16004  }
16005  bool swig_val;
16006  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16007  if (!SWIG_IsOK(swig_res)) {
16008  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16009  }
16010  c_result = static_cast< bool >(swig_val);
16011  return (bool) c_result;
16012 }
16013 
16014 
16015 void SwigDirector_SpaceShower::prepare(int arg0, Pythia8::Event &arg1, bool arg2) {
16017  obj0 = SWIG_From_int(static_cast< int >(arg0));
16019  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
16021  obj2 = SWIG_From_bool(static_cast< bool >(arg2));
16022  if (!swig_get_self()) {
16023  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16024  }
16025 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16026  const size_t swig_method_index = 4;
16027  const char * const swig_method_name = "prepare";
16028  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16029  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16030 #else
16031  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"prepare", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16032 #endif
16033  if (!result) {
16034  PyObject *error = PyErr_Occurred();
16035  if (error) {
16036  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.prepare'");
16037  }
16038  }
16039 }
16040 
16041 
16042 void SwigDirector_SpaceShower::update(int arg0, Pythia8::Event &arg1, bool arg2) {
16044  obj0 = SWIG_From_int(static_cast< int >(arg0));
16046  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
16048  obj2 = SWIG_From_bool(static_cast< bool >(arg2));
16049  if (!swig_get_self()) {
16050  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16051  }
16052 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16053  const size_t swig_method_index = 6;
16054  const char * const swig_method_name = "update";
16055  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16056  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16057 #else
16058  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"update", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16059 #endif
16060  if (!result) {
16061  PyObject *error = PyErr_Occurred();
16062  if (error) {
16063  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.update'");
16064  }
16065  }
16066 }
16067 
16068 
16069 double SwigDirector_SpaceShower::pTnext(Pythia8::Event &arg0, double arg1, double arg2, int arg3, bool arg4) {
16070  double c_result;
16072  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16074  obj1 = SWIG_From_double(static_cast< double >(arg1));
16076  obj2 = SWIG_From_double(static_cast< double >(arg2));
16078  obj3 = SWIG_From_int(static_cast< int >(arg3));
16080  obj4 = SWIG_From_bool(static_cast< bool >(arg4));
16081  if (!swig_get_self()) {
16082  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16083  }
16084 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16085  const size_t swig_method_index = 8;
16086  const char * const swig_method_name = "pTnext";
16087  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16088  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16089 #else
16090  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"pTnext", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16091 #endif
16092  if (!result) {
16093  PyObject *error = PyErr_Occurred();
16094  if (error) {
16095  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.pTnext'");
16096  }
16097  }
16098  double swig_val;
16099  int swig_res = SWIG_AsVal_double(result, &swig_val);
16100  if (!SWIG_IsOK(swig_res)) {
16101  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
16102  }
16103  c_result = static_cast< double >(swig_val);
16104  return (double) c_result;
16105 }
16106 
16107 
16108 bool SwigDirector_SpaceShower::branch(Pythia8::Event &arg0) {
16109  bool c_result;
16111  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16112  if (!swig_get_self()) {
16113  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16114  }
16115 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16116  const size_t swig_method_index = 11;
16117  const char * const swig_method_name = "branch";
16118  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16119  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
16120 #else
16121  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"branch", (char *)"(O)" ,(PyObject *)obj0);
16122 #endif
16123  if (!result) {
16124  PyObject *error = PyErr_Occurred();
16125  if (error) {
16126  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.branch'");
16127  }
16128  }
16129  bool swig_val;
16130  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16131  if (!SWIG_IsOK(swig_res)) {
16132  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16133  }
16134  c_result = static_cast< bool >(swig_val);
16135  return (bool) c_result;
16136 }
16137 
16138 
16139 bool SwigDirector_SpaceShower::initUncertainties() {
16140  bool c_result;
16141  if (!swig_get_self()) {
16142  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16143  }
16144 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16145  const size_t swig_method_index = 12;
16146  const char * const swig_method_name = "initUncertainties";
16147  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16148  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
16149 #else
16150  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initUncertainties", NULL);
16151 #endif
16152  if (!result) {
16153  PyObject *error = PyErr_Occurred();
16154  if (error) {
16155  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.initUncertainties'");
16156  }
16157  }
16158  bool swig_val;
16159  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16160  if (!SWIG_IsOK(swig_res)) {
16161  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16162  }
16163  c_result = static_cast< bool >(swig_val);
16164  return (bool) c_result;
16165 }
16166 
16167 
16168 bool SwigDirector_SpaceShower::doRestart() const {
16169  bool c_result;
16170  if (!swig_get_self()) {
16171  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16172  }
16173 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16174  const size_t swig_method_index = 13;
16175  const char * const swig_method_name = "doRestart";
16176  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16177  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
16178 #else
16179  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "doRestart", NULL);
16180 #endif
16181  if (!result) {
16182  PyObject *error = PyErr_Occurred();
16183  if (error) {
16184  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.doRestart'");
16185  }
16186  }
16187  bool swig_val;
16188  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16189  if (!SWIG_IsOK(swig_res)) {
16190  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16191  }
16192  c_result = static_cast< bool >(swig_val);
16193  return (bool) c_result;
16194 }
16195 
16196 
16197 bool SwigDirector_SpaceShower::wasGamma2qqbar() {
16198  bool c_result;
16199  if (!swig_get_self()) {
16200  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16201  }
16202 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16203  const size_t swig_method_index = 14;
16204  const char * const swig_method_name = "wasGamma2qqbar";
16205  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16206  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
16207 #else
16208  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "wasGamma2qqbar", NULL);
16209 #endif
16210  if (!result) {
16211  PyObject *error = PyErr_Occurred();
16212  if (error) {
16213  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.wasGamma2qqbar'");
16214  }
16215  }
16216  bool swig_val;
16217  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16218  if (!SWIG_IsOK(swig_res)) {
16219  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16220  }
16221  c_result = static_cast< bool >(swig_val);
16222  return (bool) c_result;
16223 }
16224 
16225 
16226 bool SwigDirector_SpaceShower::getHasWeaklyRadiated() {
16227  bool c_result;
16228  if (!swig_get_self()) {
16229  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16230  }
16231 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16232  const size_t swig_method_index = 15;
16233  const char * const swig_method_name = "getHasWeaklyRadiated";
16234  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16235  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
16236 #else
16237  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getHasWeaklyRadiated", NULL);
16238 #endif
16239  if (!result) {
16240  PyObject *error = PyErr_Occurred();
16241  if (error) {
16242  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.getHasWeaklyRadiated'");
16243  }
16244  }
16245  bool swig_val;
16246  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16247  if (!SWIG_IsOK(swig_res)) {
16248  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16249  }
16250  c_result = static_cast< bool >(swig_val);
16251  return (bool) c_result;
16252 }
16253 
16254 
16255 int SwigDirector_SpaceShower::system() const {
16256  int c_result;
16257  if (!swig_get_self()) {
16258  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16259  }
16260 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16261  const size_t swig_method_index = 16;
16262  const char * const swig_method_name = "system";
16263  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16264  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
16265 #else
16266  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "system", NULL);
16267 #endif
16268  if (!result) {
16269  PyObject *error = PyErr_Occurred();
16270  if (error) {
16271  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.system'");
16272  }
16273  }
16274  int swig_val;
16275  int swig_res = SWIG_AsVal_int(result, &swig_val);
16276  if (!SWIG_IsOK(swig_res)) {
16277  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
16278  }
16279  c_result = static_cast< int >(swig_val);
16280  return (int) c_result;
16281 }
16282 
16283 
16284 double SwigDirector_SpaceShower::enhancePTmax() const {
16285  double c_result;
16286  if (!swig_get_self()) {
16287  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16288  }
16289 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16290  const size_t swig_method_index = 17;
16291  const char * const swig_method_name = "enhancePTmax";
16292  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16293  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
16294 #else
16295  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "enhancePTmax", NULL);
16296 #endif
16297  if (!result) {
16298  PyObject *error = PyErr_Occurred();
16299  if (error) {
16300  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.enhancePTmax'");
16301  }
16302  }
16303  double swig_val;
16304  int swig_res = SWIG_AsVal_double(result, &swig_val);
16305  if (!SWIG_IsOK(swig_res)) {
16306  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
16307  }
16308  c_result = static_cast< double >(swig_val);
16309  return (double) c_result;
16310 }
16311 
16312 
16313 Pythia8::Event SwigDirector_SpaceShower::clustered(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
16314  void *swig_argp ;
16315  int swig_res = 0 ;
16316 
16317  Pythia8::Event c_result;
16319  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16321  obj1 = SWIG_From_int(static_cast< int >(arg1));
16323  obj2 = SWIG_From_int(static_cast< int >(arg2));
16325  obj3 = SWIG_From_int(static_cast< int >(arg3));
16327  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
16328  if (!swig_get_self()) {
16329  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16330  }
16331 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16332  const size_t swig_method_index = 18;
16333  const char * const swig_method_name = "clustered";
16334  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16335  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16336 #else
16337  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"clustered", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16338 #endif
16339  if (!result) {
16340  PyObject *error = PyErr_Occurred();
16341  if (error) {
16342  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.clustered'");
16343  }
16344  }
16345  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_Pythia8__Event, 0 | 0);
16346  if (!SWIG_IsOK(swig_res)) {
16347  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Pythia8::Event""'");
16348  }
16349  c_result = *(reinterpret_cast< Pythia8::Event * >(swig_argp));
16350  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< Pythia8::Event * >(swig_argp);
16351  return (Pythia8::Event) c_result;
16352 }
16353 
16354 
16355 std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > SwigDirector_SpaceShower::getStateVariables(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
16356  void *swig_argp ;
16357  int swig_res = 0 ;
16358 
16359  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > c_result;
16361  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16363  obj1 = SWIG_From_int(static_cast< int >(arg1));
16365  obj2 = SWIG_From_int(static_cast< int >(arg2));
16367  obj3 = SWIG_From_int(static_cast< int >(arg3));
16369  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
16370  if (!swig_get_self()) {
16371  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16372  }
16373 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16374  const size_t swig_method_index = 19;
16375  const char * const swig_method_name = "getStateVariables";
16376  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16377  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16378 #else
16379  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getStateVariables", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16380 #endif
16381  if (!result) {
16382  PyObject *error = PyErr_Occurred();
16383  if (error) {
16384  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.getStateVariables'");
16385  }
16386  }
16387  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0 | 0);
16388  if (!SWIG_IsOK(swig_res)) {
16389  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >""'");
16390  }
16391  c_result = *(reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(swig_argp));
16392  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(swig_argp);
16393  return (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >) c_result;
16394 }
16395 
16396 
16397 bool SwigDirector_SpaceShower::isSpacelike(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
16398  bool c_result;
16400  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16402  obj1 = SWIG_From_int(static_cast< int >(arg1));
16404  obj2 = SWIG_From_int(static_cast< int >(arg2));
16406  obj3 = SWIG_From_int(static_cast< int >(arg3));
16408  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
16409  if (!swig_get_self()) {
16410  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16411  }
16412 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16413  const size_t swig_method_index = 20;
16414  const char * const swig_method_name = "isSpacelike";
16415  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16416  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16417 #else
16418  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"isSpacelike", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16419 #endif
16420  if (!result) {
16421  PyObject *error = PyErr_Occurred();
16422  if (error) {
16423  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.isSpacelike'");
16424  }
16425  }
16426  bool swig_val;
16427  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16428  if (!SWIG_IsOK(swig_res)) {
16429  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16430  }
16431  c_result = static_cast< bool >(swig_val);
16432  return (bool) c_result;
16433 }
16434 
16435 
16436 std::vector< std::string,std::allocator< std::string > > SwigDirector_SpaceShower::getSplittingName(Pythia8::Event const &arg0, int arg1, int arg2, int arg3) {
16437  std::vector< std::string,std::allocator< std::string > > c_result;
16439  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16441  obj1 = SWIG_From_int(static_cast< int >(arg1));
16443  obj2 = SWIG_From_int(static_cast< int >(arg2));
16445  obj3 = SWIG_From_int(static_cast< int >(arg3));
16446  if (!swig_get_self()) {
16447  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16448  }
16449 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16450  const size_t swig_method_index = 21;
16451  const char * const swig_method_name = "getSplittingName";
16452  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16453  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
16454 #else
16455  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getSplittingName", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
16456 #endif
16457  if (!result) {
16458  PyObject *error = PyErr_Occurred();
16459  if (error) {
16460  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.getSplittingName'");
16461  }
16462  }
16463  std::vector< std::string,std::allocator< std::string > > *swig_optr = 0;
16464  int swig_ores = swig::asptr(result, &swig_optr);
16465  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
16466  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< std::string,std::allocator< std::string > >""'");
16467  }
16468  c_result = *swig_optr;
16469  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
16470  return (std::vector< std::string,std::allocator< std::string > >) c_result;
16471 }
16472 
16473 
16474 double SwigDirector_SpaceShower::getSplittingProb(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
16475  double c_result;
16477  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16479  obj1 = SWIG_From_int(static_cast< int >(arg1));
16481  obj2 = SWIG_From_int(static_cast< int >(arg2));
16483  obj3 = SWIG_From_int(static_cast< int >(arg3));
16485  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
16486  if (!swig_get_self()) {
16487  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16488  }
16489 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16490  const size_t swig_method_index = 22;
16491  const char * const swig_method_name = "getSplittingProb";
16492  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16493  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16494 #else
16495  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getSplittingProb", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16496 #endif
16497  if (!result) {
16498  PyObject *error = PyErr_Occurred();
16499  if (error) {
16500  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.getSplittingProb'");
16501  }
16502  }
16503  double swig_val;
16504  int swig_res = SWIG_AsVal_double(result, &swig_val);
16505  if (!SWIG_IsOK(swig_res)) {
16506  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
16507  }
16508  c_result = static_cast< double >(swig_val);
16509  return (double) c_result;
16510 }
16511 
16512 
16513 bool SwigDirector_SpaceShower::allowedSplitting(Pythia8::Event const &arg0, int arg1, int arg2) {
16514  bool c_result;
16516  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16518  obj1 = SWIG_From_int(static_cast< int >(arg1));
16520  obj2 = SWIG_From_int(static_cast< int >(arg2));
16521  if (!swig_get_self()) {
16522  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16523  }
16524 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16525  const size_t swig_method_index = 23;
16526  const char * const swig_method_name = "allowedSplitting";
16527  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16528  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16529 #else
16530  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"allowedSplitting", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16531 #endif
16532  if (!result) {
16533  PyObject *error = PyErr_Occurred();
16534  if (error) {
16535  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.allowedSplitting'");
16536  }
16537  }
16538  bool swig_val;
16539  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16540  if (!SWIG_IsOK(swig_res)) {
16541  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16542  }
16543  c_result = static_cast< bool >(swig_val);
16544  return (bool) c_result;
16545 }
16546 
16547 
16548 std::vector< int,std::allocator< int > > SwigDirector_SpaceShower::getRecoilers(Pythia8::Event const &arg0, int arg1, int arg2, std::string arg3) {
16549  std::vector< int,std::allocator< int > > c_result;
16551  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16553  obj1 = SWIG_From_int(static_cast< int >(arg1));
16555  obj2 = SWIG_From_int(static_cast< int >(arg2));
16557  obj3 = SWIG_From_std_string(static_cast< std::string >(arg3));
16558  if (!swig_get_self()) {
16559  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
16560  }
16561 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16562  const size_t swig_method_index = 24;
16563  const char * const swig_method_name = "getRecoilers";
16564  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16565  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
16566 #else
16567  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getRecoilers", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
16568 #endif
16569  if (!result) {
16570  PyObject *error = PyErr_Occurred();
16571  if (error) {
16572  Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.getRecoilers'");
16573  }
16574  }
16575  std::vector< int,std::allocator< int > > *swig_optr = 0;
16576  int swig_ores = swig::asptr(result, &swig_optr);
16577  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
16578  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< int,std::allocator< int > >""'");
16579  }
16580  c_result = *swig_optr;
16581  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
16582  return (std::vector< int,std::allocator< int > >) c_result;
16583 }
16584 
16585 
16586 SwigDirector_TimeShower::SwigDirector_TimeShower(PyObject *self): Pythia8::TimeShower(), Swig::Director(self) {
16587  SWIG_DIRECTOR_RGTR((Pythia8::TimeShower *)this, this);
16588 }
16589 
16590 
16591 
16592 
16593 SwigDirector_TimeShower::~SwigDirector_TimeShower() {
16594 }
16595 
16596 void SwigDirector_TimeShower::init(Pythia8::BeamParticle *arg0, Pythia8::BeamParticle *arg1) {
16598  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_Pythia8__BeamParticle, 0 );
16600  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(arg1), SWIGTYPE_p_Pythia8__BeamParticle, 0 );
16601  if (!swig_get_self()) {
16602  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16603  }
16604 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16605  const size_t swig_method_index = 0;
16606  const char * const swig_method_name = "init";
16607  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16608  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
16609 #else
16610  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"init", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
16611 #endif
16612  if (!result) {
16613  PyObject *error = PyErr_Occurred();
16614  if (error) {
16615  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.init'");
16616  }
16617  }
16618 }
16619 
16620 
16621 bool SwigDirector_TimeShower::limitPTmax(Pythia8::Event &arg0, double arg1, double arg2) {
16622  bool c_result;
16624  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16626  obj1 = SWIG_From_double(static_cast< double >(arg1));
16628  obj2 = SWIG_From_double(static_cast< double >(arg2));
16629  if (!swig_get_self()) {
16630  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16631  }
16632 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16633  const size_t swig_method_index = 3;
16634  const char * const swig_method_name = "limitPTmax";
16635  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16636  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16637 #else
16638  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"limitPTmax", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16639 #endif
16640  if (!result) {
16641  PyObject *error = PyErr_Occurred();
16642  if (error) {
16643  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.limitPTmax'");
16644  }
16645  }
16646  bool swig_val;
16647  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16648  if (!SWIG_IsOK(swig_res)) {
16649  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16650  }
16651  c_result = static_cast< bool >(swig_val);
16652  return (bool) c_result;
16653 }
16654 
16655 
16656 int SwigDirector_TimeShower::shower(int arg0, int arg1, Pythia8::Event &arg2, double arg3, int arg4) {
16657  int c_result;
16659  obj0 = SWIG_From_int(static_cast< int >(arg0));
16661  obj1 = SWIG_From_int(static_cast< int >(arg1));
16663  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg2), SWIGTYPE_p_Pythia8__Event, 0 );
16665  obj3 = SWIG_From_double(static_cast< double >(arg3));
16667  obj4 = SWIG_From_int(static_cast< int >(arg4));
16668  if (!swig_get_self()) {
16669  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16670  }
16671 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16672  const size_t swig_method_index = 6;
16673  const char * const swig_method_name = "shower";
16674  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16675  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16676 #else
16677  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"shower", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16678 #endif
16679  if (!result) {
16680  PyObject *error = PyErr_Occurred();
16681  if (error) {
16682  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.shower'");
16683  }
16684  }
16685  int swig_val;
16686  int swig_res = SWIG_AsVal_int(result, &swig_val);
16687  if (!SWIG_IsOK(swig_res)) {
16688  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
16689  }
16690  c_result = static_cast< int >(swig_val);
16691  return (int) c_result;
16692 }
16693 
16694 
16695 int SwigDirector_TimeShower::showerQED(int arg0, int arg1, Pythia8::Event &arg2, double arg3) {
16696  int c_result;
16698  obj0 = SWIG_From_int(static_cast< int >(arg0));
16700  obj1 = SWIG_From_int(static_cast< int >(arg1));
16702  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg2), SWIGTYPE_p_Pythia8__Event, 0 );
16704  obj3 = SWIG_From_double(static_cast< double >(arg3));
16705  if (!swig_get_self()) {
16706  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16707  }
16708 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16709  const size_t swig_method_index = 8;
16710  const char * const swig_method_name = "showerQED";
16711  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16712  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
16713 #else
16714  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"showerQED", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
16715 #endif
16716  if (!result) {
16717  PyObject *error = PyErr_Occurred();
16718  if (error) {
16719  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.showerQED'");
16720  }
16721  }
16722  int swig_val;
16723  int swig_res = SWIG_AsVal_int(result, &swig_val);
16724  if (!SWIG_IsOK(swig_res)) {
16725  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
16726  }
16727  c_result = static_cast< int >(swig_val);
16728  return (int) c_result;
16729 }
16730 
16731 
16732 int SwigDirector_TimeShower::showerQEDafterRemnants(Pythia8::Event &arg0) {
16733  int c_result;
16735  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16736  if (!swig_get_self()) {
16737  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16738  }
16739 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16740  const size_t swig_method_index = 9;
16741  const char * const swig_method_name = "showerQEDafterRemnants";
16742  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16743  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
16744 #else
16745  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"showerQEDafterRemnants", (char *)"(O)" ,(PyObject *)obj0);
16746 #endif
16747  if (!result) {
16748  PyObject *error = PyErr_Occurred();
16749  if (error) {
16750  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.showerQEDafterRemnants'");
16751  }
16752  }
16753  int swig_val;
16754  int swig_res = SWIG_AsVal_int(result, &swig_val);
16755  if (!SWIG_IsOK(swig_res)) {
16756  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
16757  }
16758  c_result = static_cast< int >(swig_val);
16759  return (int) c_result;
16760 }
16761 
16762 
16763 void SwigDirector_TimeShower::prepareGlobal(Pythia8::Event &arg0) {
16765  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16766  if (!swig_get_self()) {
16767  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16768  }
16769 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16770  const size_t swig_method_index = 10;
16771  const char * const swig_method_name = "prepareGlobal";
16772  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16773  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
16774 #else
16775  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"prepareGlobal", (char *)"(O)" ,(PyObject *)obj0);
16776 #endif
16777  if (!result) {
16778  PyObject *error = PyErr_Occurred();
16779  if (error) {
16780  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.prepareGlobal'");
16781  }
16782  }
16783 }
16784 
16785 
16786 void SwigDirector_TimeShower::prepare(int arg0, Pythia8::Event &arg1, bool arg2) {
16788  obj0 = SWIG_From_int(static_cast< int >(arg0));
16790  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
16792  obj2 = SWIG_From_bool(static_cast< bool >(arg2));
16793  if (!swig_get_self()) {
16794  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16795  }
16796 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16797  const size_t swig_method_index = 11;
16798  const char * const swig_method_name = "prepare";
16799  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16800  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16801 #else
16802  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"prepare", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16803 #endif
16804  if (!result) {
16805  PyObject *error = PyErr_Occurred();
16806  if (error) {
16807  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.prepare'");
16808  }
16809  }
16810 }
16811 
16812 
16813 void SwigDirector_TimeShower::rescatterUpdate(int arg0, Pythia8::Event &arg1) {
16815  obj0 = SWIG_From_int(static_cast< int >(arg0));
16817  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
16818  if (!swig_get_self()) {
16819  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16820  }
16821 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16822  const size_t swig_method_index = 13;
16823  const char * const swig_method_name = "rescatterUpdate";
16824  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16825  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
16826 #else
16827  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"rescatterUpdate", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
16828 #endif
16829  if (!result) {
16830  PyObject *error = PyErr_Occurred();
16831  if (error) {
16832  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.rescatterUpdate'");
16833  }
16834  }
16835 }
16836 
16837 
16838 void SwigDirector_TimeShower::update(int arg0, Pythia8::Event &arg1, bool arg2) {
16840  obj0 = SWIG_From_int(static_cast< int >(arg0));
16842  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event, 0 );
16844  obj2 = SWIG_From_bool(static_cast< bool >(arg2));
16845  if (!swig_get_self()) {
16846  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16847  }
16848 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16849  const size_t swig_method_index = 14;
16850  const char * const swig_method_name = "update";
16851  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16852  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16853 #else
16854  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"update", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
16855 #endif
16856  if (!result) {
16857  PyObject *error = PyErr_Occurred();
16858  if (error) {
16859  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.update'");
16860  }
16861  }
16862 }
16863 
16864 
16865 double SwigDirector_TimeShower::pTnext(Pythia8::Event &arg0, double arg1, double arg2, bool arg3, bool arg4) {
16866  double c_result;
16868  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16870  obj1 = SWIG_From_double(static_cast< double >(arg1));
16872  obj2 = SWIG_From_double(static_cast< double >(arg2));
16874  obj3 = SWIG_From_bool(static_cast< bool >(arg3));
16876  obj4 = SWIG_From_bool(static_cast< bool >(arg4));
16877  if (!swig_get_self()) {
16878  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16879  }
16880 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16881  const size_t swig_method_index = 16;
16882  const char * const swig_method_name = "pTnext";
16883  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16884  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16885 #else
16886  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"pTnext", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
16887 #endif
16888  if (!result) {
16889  PyObject *error = PyErr_Occurred();
16890  if (error) {
16891  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.pTnext'");
16892  }
16893  }
16894  double swig_val;
16895  int swig_res = SWIG_AsVal_double(result, &swig_val);
16896  if (!SWIG_IsOK(swig_res)) {
16897  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
16898  }
16899  c_result = static_cast< double >(swig_val);
16900  return (double) c_result;
16901 }
16902 
16903 
16904 bool SwigDirector_TimeShower::branch(Pythia8::Event &arg0, bool arg1) {
16905  bool c_result;
16907  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
16909  obj1 = SWIG_From_bool(static_cast< bool >(arg1));
16910  if (!swig_get_self()) {
16911  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16912  }
16913 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16914  const size_t swig_method_index = 19;
16915  const char * const swig_method_name = "branch";
16916  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16917  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
16918 #else
16919  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"branch", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
16920 #endif
16921  if (!result) {
16922  PyObject *error = PyErr_Occurred();
16923  if (error) {
16924  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.branch'");
16925  }
16926  }
16927  bool swig_val;
16928  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16929  if (!SWIG_IsOK(swig_res)) {
16930  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16931  }
16932  c_result = static_cast< bool >(swig_val);
16933  return (bool) c_result;
16934 }
16935 
16936 
16937 bool SwigDirector_TimeShower::initUncertainties() {
16938  bool c_result;
16939  if (!swig_get_self()) {
16940  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16941  }
16942 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16943  const size_t swig_method_index = 21;
16944  const char * const swig_method_name = "initUncertainties";
16945  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16946  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
16947 #else
16948  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initUncertainties", NULL);
16949 #endif
16950  if (!result) {
16951  PyObject *error = PyErr_Occurred();
16952  if (error) {
16953  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.initUncertainties'");
16954  }
16955  }
16956  bool swig_val;
16957  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16958  if (!SWIG_IsOK(swig_res)) {
16959  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16960  }
16961  c_result = static_cast< bool >(swig_val);
16962  return (bool) c_result;
16963 }
16964 
16965 
16966 bool SwigDirector_TimeShower::getHasWeaklyRadiated() {
16967  bool c_result;
16968  if (!swig_get_self()) {
16969  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16970  }
16971 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
16972  const size_t swig_method_index = 22;
16973  const char * const swig_method_name = "getHasWeaklyRadiated";
16974  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
16975  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
16976 #else
16977  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getHasWeaklyRadiated", NULL);
16978 #endif
16979  if (!result) {
16980  PyObject *error = PyErr_Occurred();
16981  if (error) {
16982  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.getHasWeaklyRadiated'");
16983  }
16984  }
16985  bool swig_val;
16986  int swig_res = SWIG_AsVal_bool(result, &swig_val);
16987  if (!SWIG_IsOK(swig_res)) {
16988  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
16989  }
16990  c_result = static_cast< bool >(swig_val);
16991  return (bool) c_result;
16992 }
16993 
16994 
16995 int SwigDirector_TimeShower::system() const {
16996  int c_result;
16997  if (!swig_get_self()) {
16998  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
16999  }
17000 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17001  const size_t swig_method_index = 23;
17002  const char * const swig_method_name = "system";
17003  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17004  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
17005 #else
17006  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "system", NULL);
17007 #endif
17008  if (!result) {
17009  PyObject *error = PyErr_Occurred();
17010  if (error) {
17011  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.system'");
17012  }
17013  }
17014  int swig_val;
17015  int swig_res = SWIG_AsVal_int(result, &swig_val);
17016  if (!SWIG_IsOK(swig_res)) {
17017  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
17018  }
17019  c_result = static_cast< int >(swig_val);
17020  return (int) c_result;
17021 }
17022 
17023 
17024 double SwigDirector_TimeShower::enhancePTmax() {
17025  double c_result;
17026  if (!swig_get_self()) {
17027  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
17028  }
17029 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17030  const size_t swig_method_index = 24;
17031  const char * const swig_method_name = "enhancePTmax";
17032  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17033  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
17034 #else
17035  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "enhancePTmax", NULL);
17036 #endif
17037  if (!result) {
17038  PyObject *error = PyErr_Occurred();
17039  if (error) {
17040  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.enhancePTmax'");
17041  }
17042  }
17043  double swig_val;
17044  int swig_res = SWIG_AsVal_double(result, &swig_val);
17045  if (!SWIG_IsOK(swig_res)) {
17046  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
17047  }
17048  c_result = static_cast< double >(swig_val);
17049  return (double) c_result;
17050 }
17051 
17052 
17053 double SwigDirector_TimeShower::pTLastInShower() {
17054  double c_result;
17055  if (!swig_get_self()) {
17056  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
17057  }
17058 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17059  const size_t swig_method_index = 25;
17060  const char * const swig_method_name = "pTLastInShower";
17061  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17062  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
17063 #else
17064  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "pTLastInShower", NULL);
17065 #endif
17066  if (!result) {
17067  PyObject *error = PyErr_Occurred();
17068  if (error) {
17069  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.pTLastInShower'");
17070  }
17071  }
17072  double swig_val;
17073  int swig_res = SWIG_AsVal_double(result, &swig_val);
17074  if (!SWIG_IsOK(swig_res)) {
17075  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
17076  }
17077  c_result = static_cast< double >(swig_val);
17078  return (double) c_result;
17079 }
17080 
17081 
17082 Pythia8::Event SwigDirector_TimeShower::clustered(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
17083  void *swig_argp ;
17084  int swig_res = 0 ;
17085 
17086  Pythia8::Event c_result;
17088  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
17090  obj1 = SWIG_From_int(static_cast< int >(arg1));
17092  obj2 = SWIG_From_int(static_cast< int >(arg2));
17094  obj3 = SWIG_From_int(static_cast< int >(arg3));
17096  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
17097  if (!swig_get_self()) {
17098  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
17099  }
17100 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17101  const size_t swig_method_index = 26;
17102  const char * const swig_method_name = "clustered";
17103  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17104  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
17105 #else
17106  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"clustered", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
17107 #endif
17108  if (!result) {
17109  PyObject *error = PyErr_Occurred();
17110  if (error) {
17111  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.clustered'");
17112  }
17113  }
17114  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_Pythia8__Event, 0 | 0);
17115  if (!SWIG_IsOK(swig_res)) {
17116  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Pythia8::Event""'");
17117  }
17118  c_result = *(reinterpret_cast< Pythia8::Event * >(swig_argp));
17119  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< Pythia8::Event * >(swig_argp);
17120  return (Pythia8::Event) c_result;
17121 }
17122 
17123 
17124 std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > SwigDirector_TimeShower::getStateVariables(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
17125  void *swig_argp ;
17126  int swig_res = 0 ;
17127 
17128  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > c_result;
17130  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
17132  obj1 = SWIG_From_int(static_cast< int >(arg1));
17134  obj2 = SWIG_From_int(static_cast< int >(arg2));
17136  obj3 = SWIG_From_int(static_cast< int >(arg3));
17138  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
17139  if (!swig_get_self()) {
17140  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
17141  }
17142 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17143  const size_t swig_method_index = 27;
17144  const char * const swig_method_name = "getStateVariables";
17145  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17146  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
17147 #else
17148  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getStateVariables", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
17149 #endif
17150  if (!result) {
17151  PyObject *error = PyErr_Occurred();
17152  if (error) {
17153  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.getStateVariables'");
17154  }
17155  }
17156  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0 | 0);
17157  if (!SWIG_IsOK(swig_res)) {
17158  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >""'");
17159  }
17160  c_result = *(reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(swig_argp));
17161  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(swig_argp);
17162  return (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >) c_result;
17163 }
17164 
17165 
17166 bool SwigDirector_TimeShower::isTimelike(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
17167  bool c_result;
17169  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
17171  obj1 = SWIG_From_int(static_cast< int >(arg1));
17173  obj2 = SWIG_From_int(static_cast< int >(arg2));
17175  obj3 = SWIG_From_int(static_cast< int >(arg3));
17177  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
17178  if (!swig_get_self()) {
17179  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
17180  }
17181 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17182  const size_t swig_method_index = 28;
17183  const char * const swig_method_name = "isTimelike";
17184  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17185  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
17186 #else
17187  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"isTimelike", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
17188 #endif
17189  if (!result) {
17190  PyObject *error = PyErr_Occurred();
17191  if (error) {
17192  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.isTimelike'");
17193  }
17194  }
17195  bool swig_val;
17196  int swig_res = SWIG_AsVal_bool(result, &swig_val);
17197  if (!SWIG_IsOK(swig_res)) {
17198  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
17199  }
17200  c_result = static_cast< bool >(swig_val);
17201  return (bool) c_result;
17202 }
17203 
17204 
17205 std::vector< std::string,std::allocator< std::string > > SwigDirector_TimeShower::getSplittingName(Pythia8::Event const &arg0, int arg1, int arg2, int arg3) {
17206  std::vector< std::string,std::allocator< std::string > > c_result;
17208  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
17210  obj1 = SWIG_From_int(static_cast< int >(arg1));
17212  obj2 = SWIG_From_int(static_cast< int >(arg2));
17214  obj3 = SWIG_From_int(static_cast< int >(arg3));
17215  if (!swig_get_self()) {
17216  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
17217  }
17218 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17219  const size_t swig_method_index = 29;
17220  const char * const swig_method_name = "getSplittingName";
17221  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17222  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
17223 #else
17224  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getSplittingName", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
17225 #endif
17226  if (!result) {
17227  PyObject *error = PyErr_Occurred();
17228  if (error) {
17229  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.getSplittingName'");
17230  }
17231  }
17232  std::vector< std::string,std::allocator< std::string > > *swig_optr = 0;
17233  int swig_ores = swig::asptr(result, &swig_optr);
17234  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
17235  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< std::string,std::allocator< std::string > >""'");
17236  }
17237  c_result = *swig_optr;
17238  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
17239  return (std::vector< std::string,std::allocator< std::string > >) c_result;
17240 }
17241 
17242 
17243 double SwigDirector_TimeShower::getSplittingProb(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
17244  double c_result;
17246  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
17248  obj1 = SWIG_From_int(static_cast< int >(arg1));
17250  obj2 = SWIG_From_int(static_cast< int >(arg2));
17252  obj3 = SWIG_From_int(static_cast< int >(arg3));
17254  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
17255  if (!swig_get_self()) {
17256  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
17257  }
17258 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17259  const size_t swig_method_index = 30;
17260  const char * const swig_method_name = "getSplittingProb";
17261  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17262  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
17263 #else
17264  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getSplittingProb", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
17265 #endif
17266  if (!result) {
17267  PyObject *error = PyErr_Occurred();
17268  if (error) {
17269  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.getSplittingProb'");
17270  }
17271  }
17272  double swig_val;
17273  int swig_res = SWIG_AsVal_double(result, &swig_val);
17274  if (!SWIG_IsOK(swig_res)) {
17275  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
17276  }
17277  c_result = static_cast< double >(swig_val);
17278  return (double) c_result;
17279 }
17280 
17281 
17282 bool SwigDirector_TimeShower::allowedSplitting(Pythia8::Event const &arg0, int arg1, int arg2) {
17283  bool c_result;
17285  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
17287  obj1 = SWIG_From_int(static_cast< int >(arg1));
17289  obj2 = SWIG_From_int(static_cast< int >(arg2));
17290  if (!swig_get_self()) {
17291  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
17292  }
17293 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17294  const size_t swig_method_index = 31;
17295  const char * const swig_method_name = "allowedSplitting";
17296  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17297  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
17298 #else
17299  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"allowedSplitting", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
17300 #endif
17301  if (!result) {
17302  PyObject *error = PyErr_Occurred();
17303  if (error) {
17304  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.allowedSplitting'");
17305  }
17306  }
17307  bool swig_val;
17308  int swig_res = SWIG_AsVal_bool(result, &swig_val);
17309  if (!SWIG_IsOK(swig_res)) {
17310  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
17311  }
17312  c_result = static_cast< bool >(swig_val);
17313  return (bool) c_result;
17314 }
17315 
17316 
17317 std::vector< int,std::allocator< int > > SwigDirector_TimeShower::getRecoilers(Pythia8::Event const &arg0, int arg1, int arg2, std::string arg3) {
17318  std::vector< int,std::allocator< int > > c_result;
17320  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event, 0 );
17322  obj1 = SWIG_From_int(static_cast< int >(arg1));
17324  obj2 = SWIG_From_int(static_cast< int >(arg2));
17326  obj3 = SWIG_From_std_string(static_cast< std::string >(arg3));
17327  if (!swig_get_self()) {
17328  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
17329  }
17330 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17331  const size_t swig_method_index = 32;
17332  const char * const swig_method_name = "getRecoilers";
17333  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17334  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
17335 #else
17336  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getRecoilers", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
17337 #endif
17338  if (!result) {
17339  PyObject *error = PyErr_Occurred();
17340  if (error) {
17341  Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.getRecoilers'");
17342  }
17343  }
17344  std::vector< int,std::allocator< int > > *swig_optr = 0;
17345  int swig_ores = swig::asptr(result, &swig_optr);
17346  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
17347  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< int,std::allocator< int > >""'");
17348  }
17349  c_result = *swig_optr;
17350  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
17351  return (std::vector< int,std::allocator< int > >) c_result;
17352 }
17353 
17354 
17355 SwigDirector_DecayHandler::SwigDirector_DecayHandler(PyObject *self): Pythia8::DecayHandler(), Swig::Director(self) {
17356  SWIG_DIRECTOR_RGTR((Pythia8::DecayHandler *)this, this);
17357 }
17358 
17359 
17360 
17361 
17362 SwigDirector_DecayHandler::~SwigDirector_DecayHandler() {
17363 }
17364 
17365 bool SwigDirector_DecayHandler::decay(std::vector< int,std::allocator< int > > &arg0, std::vector< double,std::allocator< double > > &arg1, std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &arg2, int arg3, Pythia8::Event const &arg4) {
17366  bool c_result;
17368  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 );
17370  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
17372  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg2), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 );
17374  obj3 = SWIG_From_int(static_cast< int >(arg3));
17376  obj4 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg4), SWIGTYPE_p_Pythia8__Event, 0 );
17377  if (!swig_get_self()) {
17378  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call DecayHandler.__init__.");
17379  }
17380 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17381  const size_t swig_method_index = 0;
17382  const char * const swig_method_name = "decay";
17383  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17384  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
17385 #else
17386  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"decay", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
17387 #endif
17388  if (!result) {
17389  PyObject *error = PyErr_Occurred();
17390  if (error) {
17391  Swig::DirectorMethodException::raise("Error detected when calling 'DecayHandler.decay'");
17392  }
17393  }
17394  bool swig_val;
17395  int swig_res = SWIG_AsVal_bool(result, &swig_val);
17396  if (!SWIG_IsOK(swig_res)) {
17397  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
17398  }
17399  c_result = static_cast< bool >(swig_val);
17400  return (bool) c_result;
17401 }
17402 
17403 
17404 bool SwigDirector_DecayHandler::chainDecay(std::vector< int,std::allocator< int > > &arg0, std::vector< int,std::allocator< int > > &arg1, std::vector< double,std::allocator< double > > &arg2, std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &arg3, int arg4, Pythia8::Event const &arg5) {
17405  bool c_result;
17407  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 );
17409  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 );
17411  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg2), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 );
17413  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg3), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 );
17415  obj4 = SWIG_From_int(static_cast< int >(arg4));
17417  obj5 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg5), SWIGTYPE_p_Pythia8__Event, 0 );
17418  if (!swig_get_self()) {
17419  Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call DecayHandler.__init__.");
17420  }
17421 #if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
17422  const size_t swig_method_index = 1;
17423  const char * const swig_method_name = "chainDecay";
17424  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
17425  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5);
17426 #else
17427  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"chainDecay", (char *)"(OOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5);
17428 #endif
17429  if (!result) {
17430  PyObject *error = PyErr_Occurred();
17431  if (error) {
17432  Swig::DirectorMethodException::raise("Error detected when calling 'DecayHandler.chainDecay'");
17433  }
17434  }
17435  bool swig_val;
17436  int swig_res = SWIG_AsVal_bool(result, &swig_val);
17437  if (!SWIG_IsOK(swig_res)) {
17438  Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
17439  }
17440  c_result = static_cast< bool >(swig_val);
17441  return (bool) c_result;
17442 }
17443 
17444 
17445 #ifdef __cplusplus
17446 extern "C" {
17447 #endif
17448 SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17449  PyObject *resultobj = 0;
17451  void *argp1 = 0 ;
17452  int res1 = 0 ;
17453  PyObject * obj0 = 0 ;
17454 
17455  if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail;
17456  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
17457  if (!SWIG_IsOK(res1)) {
17458  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
17459  }
17460  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17461  delete arg1;
17462  resultobj = SWIG_Py_Void();
17463  return resultobj;
17464 fail:
17465  return NULL;
17466 }
17467 
17468 
17469 SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17470  PyObject *resultobj = 0;
17472  void *argp1 = 0 ;
17473  int res1 = 0 ;
17474  PyObject * obj0 = 0 ;
17475  PyObject *result = 0 ;
17476 
17477  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail;
17478  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17479  if (!SWIG_IsOK(res1)) {
17480  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
17481  }
17482  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17483  try {
17484  result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
17485  }
17486  catch(swig::stop_iteration &_e) {
17487  {
17488  (void)_e;
17489  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
17490  SWIG_fail;
17491  }
17492  }
17493 
17494  resultobj = result;
17495  return resultobj;
17496 fail:
17497  return NULL;
17498 }
17499 
17500 
17501 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17502  PyObject *resultobj = 0;
17504  size_t arg2 ;
17505  void *argp1 = 0 ;
17506  int res1 = 0 ;
17507  size_t val2 ;
17508  int ecode2 = 0 ;
17509  PyObject * obj0 = 0 ;
17510  PyObject * obj1 = 0 ;
17511  swig::SwigPyIterator *result = 0 ;
17512 
17513  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail;
17514  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17515  if (!SWIG_IsOK(res1)) {
17516  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
17517  }
17518  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17519  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17520  if (!SWIG_IsOK(ecode2)) {
17521  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
17522  }
17523  arg2 = static_cast< size_t >(val2);
17524  try {
17525  result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
17526  }
17527  catch(swig::stop_iteration &_e) {
17528  {
17529  (void)_e;
17530  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
17531  SWIG_fail;
17532  }
17533  }
17534 
17535  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17536  return resultobj;
17537 fail:
17538  return NULL;
17539 }
17540 
17541 
17542 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17543  PyObject *resultobj = 0;
17545  void *argp1 = 0 ;
17546  int res1 = 0 ;
17547  PyObject * obj0 = 0 ;
17548  swig::SwigPyIterator *result = 0 ;
17549 
17550  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail;
17551  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17552  if (!SWIG_IsOK(res1)) {
17553  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
17554  }
17555  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17556  try {
17557  result = (swig::SwigPyIterator *)(arg1)->incr();
17558  }
17559  catch(swig::stop_iteration &_e) {
17560  {
17561  (void)_e;
17562  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
17563  SWIG_fail;
17564  }
17565  }
17566 
17567  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17568  return resultobj;
17569 fail:
17570  return NULL;
17571 }
17572 
17573 
17574 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
17575  Py_ssize_t argc;
17576  PyObject *argv[3] = {
17577  0
17578  };
17579  Py_ssize_t ii;
17580 
17581  if (!PyTuple_Check(args)) SWIG_fail;
17582  argc = args ? PyObject_Length(args) : 0;
17583  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
17584  argv[ii] = PyTuple_GET_ITEM(args,ii);
17585  }
17586  if (argc == 1) {
17587  int _v;
17588  void *vptr = 0;
17589  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
17590  _v = SWIG_CheckState(res);
17591  if (_v) {
17592  return _wrap_SwigPyIterator_incr__SWIG_1(self, args);
17593  }
17594  }
17595  if (argc == 2) {
17596  int _v;
17597  void *vptr = 0;
17598  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
17599  _v = SWIG_CheckState(res);
17600  if (_v) {
17601  {
17602  int res = SWIG_AsVal_size_t(argv[1], NULL);
17603  _v = SWIG_CheckState(res);
17604  }
17605  if (_v) {
17606  return _wrap_SwigPyIterator_incr__SWIG_0(self, args);
17607  }
17608  }
17609  }
17610 
17611 fail:
17612  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
17613  " Possible C/C++ prototypes are:\n"
17614  " swig::SwigPyIterator::incr(size_t)\n"
17615  " swig::SwigPyIterator::incr()\n");
17616  return 0;
17617 }
17618 
17619 
17620 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17621  PyObject *resultobj = 0;
17623  size_t arg2 ;
17624  void *argp1 = 0 ;
17625  int res1 = 0 ;
17626  size_t val2 ;
17627  int ecode2 = 0 ;
17628  PyObject * obj0 = 0 ;
17629  PyObject * obj1 = 0 ;
17630  swig::SwigPyIterator *result = 0 ;
17631 
17632  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail;
17633  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17634  if (!SWIG_IsOK(res1)) {
17635  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
17636  }
17637  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17638  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17639  if (!SWIG_IsOK(ecode2)) {
17640  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
17641  }
17642  arg2 = static_cast< size_t >(val2);
17643  try {
17644  result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
17645  }
17646  catch(swig::stop_iteration &_e) {
17647  {
17648  (void)_e;
17649  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
17650  SWIG_fail;
17651  }
17652  }
17653 
17654  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17655  return resultobj;
17656 fail:
17657  return NULL;
17658 }
17659 
17660 
17661 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17662  PyObject *resultobj = 0;
17664  void *argp1 = 0 ;
17665  int res1 = 0 ;
17666  PyObject * obj0 = 0 ;
17667  swig::SwigPyIterator *result = 0 ;
17668 
17669  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail;
17670  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17671  if (!SWIG_IsOK(res1)) {
17672  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
17673  }
17674  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17675  try {
17676  result = (swig::SwigPyIterator *)(arg1)->decr();
17677  }
17678  catch(swig::stop_iteration &_e) {
17679  {
17680  (void)_e;
17681  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
17682  SWIG_fail;
17683  }
17684  }
17685 
17686  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17687  return resultobj;
17688 fail:
17689  return NULL;
17690 }
17691 
17692 
17693 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
17694  Py_ssize_t argc;
17695  PyObject *argv[3] = {
17696  0
17697  };
17698  Py_ssize_t ii;
17699 
17700  if (!PyTuple_Check(args)) SWIG_fail;
17701  argc = args ? PyObject_Length(args) : 0;
17702  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
17703  argv[ii] = PyTuple_GET_ITEM(args,ii);
17704  }
17705  if (argc == 1) {
17706  int _v;
17707  void *vptr = 0;
17708  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
17709  _v = SWIG_CheckState(res);
17710  if (_v) {
17711  return _wrap_SwigPyIterator_decr__SWIG_1(self, args);
17712  }
17713  }
17714  if (argc == 2) {
17715  int _v;
17716  void *vptr = 0;
17717  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
17718  _v = SWIG_CheckState(res);
17719  if (_v) {
17720  {
17721  int res = SWIG_AsVal_size_t(argv[1], NULL);
17722  _v = SWIG_CheckState(res);
17723  }
17724  if (_v) {
17725  return _wrap_SwigPyIterator_decr__SWIG_0(self, args);
17726  }
17727  }
17728  }
17729 
17730 fail:
17731  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
17732  " Possible C/C++ prototypes are:\n"
17733  " swig::SwigPyIterator::decr(size_t)\n"
17734  " swig::SwigPyIterator::decr()\n");
17735  return 0;
17736 }
17737 
17738 
17739 SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17740  PyObject *resultobj = 0;
17742  swig::SwigPyIterator *arg2 = 0 ;
17743  void *argp1 = 0 ;
17744  int res1 = 0 ;
17745  void *argp2 = 0 ;
17746  int res2 = 0 ;
17747  PyObject * obj0 = 0 ;
17748  PyObject * obj1 = 0 ;
17749  ptrdiff_t result;
17750 
17751  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail;
17752  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17753  if (!SWIG_IsOK(res1)) {
17754  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
17755  }
17756  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17757  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
17758  if (!SWIG_IsOK(res2)) {
17759  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
17760  }
17761  if (!argp2) {
17762  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
17763  }
17764  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
17765  try {
17766  result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
17767  }
17768  catch(std::invalid_argument &_e) {
17769  SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
17770  }
17771 
17772  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
17773  return resultobj;
17774 fail:
17775  return NULL;
17776 }
17777 
17778 
17779 SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17780  PyObject *resultobj = 0;
17782  swig::SwigPyIterator *arg2 = 0 ;
17783  void *argp1 = 0 ;
17784  int res1 = 0 ;
17785  void *argp2 = 0 ;
17786  int res2 = 0 ;
17787  PyObject * obj0 = 0 ;
17788  PyObject * obj1 = 0 ;
17789  bool result;
17790 
17791  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail;
17792  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17793  if (!SWIG_IsOK(res1)) {
17794  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
17795  }
17796  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17797  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
17798  if (!SWIG_IsOK(res2)) {
17799  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
17800  }
17801  if (!argp2) {
17802  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
17803  }
17804  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
17805  try {
17806  result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
17807  }
17808  catch(std::invalid_argument &_e) {
17809  SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
17810  }
17811 
17812  resultobj = SWIG_From_bool(static_cast< bool >(result));
17813  return resultobj;
17814 fail:
17815  return NULL;
17816 }
17817 
17818 
17819 SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17820  PyObject *resultobj = 0;
17822  void *argp1 = 0 ;
17823  int res1 = 0 ;
17824  PyObject * obj0 = 0 ;
17825  swig::SwigPyIterator *result = 0 ;
17826 
17827  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail;
17828  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17829  if (!SWIG_IsOK(res1)) {
17830  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
17831  }
17832  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17833  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
17834  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
17835  return resultobj;
17836 fail:
17837  return NULL;
17838 }
17839 
17840 
17841 SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17842  PyObject *resultobj = 0;
17844  void *argp1 = 0 ;
17845  int res1 = 0 ;
17846  PyObject * obj0 = 0 ;
17847  PyObject *result = 0 ;
17848 
17849  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail;
17850  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17851  if (!SWIG_IsOK(res1)) {
17852  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
17853  }
17854  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17855  try {
17856  result = (PyObject *)(arg1)->next();
17857  }
17858  catch(swig::stop_iteration &_e) {
17859  {
17860  (void)_e;
17861  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
17862  SWIG_fail;
17863  }
17864  }
17865 
17866  resultobj = result;
17867  return resultobj;
17868 fail:
17869  return NULL;
17870 }
17871 
17872 
17873 SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17874  PyObject *resultobj = 0;
17876  void *argp1 = 0 ;
17877  int res1 = 0 ;
17878  PyObject * obj0 = 0 ;
17879  PyObject *result = 0 ;
17880 
17881  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail;
17882  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17883  if (!SWIG_IsOK(res1)) {
17884  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
17885  }
17886  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17887  try {
17888  result = (PyObject *)(arg1)->__next__();
17889  }
17890  catch(swig::stop_iteration &_e) {
17891  {
17892  (void)_e;
17893  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
17894  SWIG_fail;
17895  }
17896  }
17897 
17898  resultobj = result;
17899  return resultobj;
17900 fail:
17901  return NULL;
17902 }
17903 
17904 
17905 SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17906  PyObject *resultobj = 0;
17908  void *argp1 = 0 ;
17909  int res1 = 0 ;
17910  PyObject * obj0 = 0 ;
17911  PyObject *result = 0 ;
17912 
17913  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail;
17914  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17915  if (!SWIG_IsOK(res1)) {
17916  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
17917  }
17918  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17919  try {
17920  result = (PyObject *)(arg1)->previous();
17921  }
17922  catch(swig::stop_iteration &_e) {
17923  {
17924  (void)_e;
17925  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
17926  SWIG_fail;
17927  }
17928  }
17929 
17930  resultobj = result;
17931  return resultobj;
17932 fail:
17933  return NULL;
17934 }
17935 
17936 
17937 SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17938  PyObject *resultobj = 0;
17940  ptrdiff_t arg2 ;
17941  void *argp1 = 0 ;
17942  int res1 = 0 ;
17943  ptrdiff_t val2 ;
17944  int ecode2 = 0 ;
17945  PyObject * obj0 = 0 ;
17946  PyObject * obj1 = 0 ;
17947  swig::SwigPyIterator *result = 0 ;
17948 
17949  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail;
17950  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17951  if (!SWIG_IsOK(res1)) {
17952  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
17953  }
17954  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17955  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
17956  if (!SWIG_IsOK(ecode2)) {
17957  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
17958  }
17959  arg2 = static_cast< ptrdiff_t >(val2);
17960  try {
17961  result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
17962  }
17963  catch(swig::stop_iteration &_e) {
17964  {
17965  (void)_e;
17966  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
17967  SWIG_fail;
17968  }
17969  }
17970 
17971  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17972  return resultobj;
17973 fail:
17974  return NULL;
17975 }
17976 
17977 
17978 SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17979  PyObject *resultobj = 0;
17981  swig::SwigPyIterator *arg2 = 0 ;
17982  void *argp1 = 0 ;
17983  int res1 = 0 ;
17984  void *argp2 = 0 ;
17985  int res2 = 0 ;
17986  PyObject * obj0 = 0 ;
17987  PyObject * obj1 = 0 ;
17988  bool result;
17989 
17990  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail;
17991  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
17992  if (!SWIG_IsOK(res1)) {
17993  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
17994  }
17995  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
17996  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
17997  if (!SWIG_IsOK(res2)) {
17998  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
17999  }
18000  if (!argp2) {
18001  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
18002  }
18003  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
18004  result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
18005  resultobj = SWIG_From_bool(static_cast< bool >(result));
18006  return resultobj;
18007 fail:
18008  return NULL;
18009 }
18010 
18011 
18012 SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18013  PyObject *resultobj = 0;
18015  swig::SwigPyIterator *arg2 = 0 ;
18016  void *argp1 = 0 ;
18017  int res1 = 0 ;
18018  void *argp2 = 0 ;
18019  int res2 = 0 ;
18020  PyObject * obj0 = 0 ;
18021  PyObject * obj1 = 0 ;
18022  bool result;
18023 
18024  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail;
18025  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
18026  if (!SWIG_IsOK(res1)) {
18027  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
18028  }
18029  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
18030  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
18031  if (!SWIG_IsOK(res2)) {
18032  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
18033  }
18034  if (!argp2) {
18035  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
18036  }
18037  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
18038  result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
18039  resultobj = SWIG_From_bool(static_cast< bool >(result));
18040  return resultobj;
18041 fail:
18042  return NULL;
18043 }
18044 
18045 
18046 SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18047  PyObject *resultobj = 0;
18049  ptrdiff_t arg2 ;
18050  void *argp1 = 0 ;
18051  int res1 = 0 ;
18052  ptrdiff_t val2 ;
18053  int ecode2 = 0 ;
18054  PyObject * obj0 = 0 ;
18055  PyObject * obj1 = 0 ;
18056  swig::SwigPyIterator *result = 0 ;
18057 
18058  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail;
18059  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
18060  if (!SWIG_IsOK(res1)) {
18061  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
18062  }
18063  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
18064  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18065  if (!SWIG_IsOK(ecode2)) {
18066  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
18067  }
18068  arg2 = static_cast< ptrdiff_t >(val2);
18069  try {
18070  result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
18071  }
18072  catch(swig::stop_iteration &_e) {
18073  {
18074  (void)_e;
18075  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18076  SWIG_fail;
18077  }
18078  }
18079 
18080  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
18081  return resultobj;
18082 fail:
18083  return NULL;
18084 }
18085 
18086 
18087 SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18088  PyObject *resultobj = 0;
18090  ptrdiff_t arg2 ;
18091  void *argp1 = 0 ;
18092  int res1 = 0 ;
18093  ptrdiff_t val2 ;
18094  int ecode2 = 0 ;
18095  PyObject * obj0 = 0 ;
18096  PyObject * obj1 = 0 ;
18097  swig::SwigPyIterator *result = 0 ;
18098 
18099  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail;
18100  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
18101  if (!SWIG_IsOK(res1)) {
18102  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
18103  }
18104  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
18105  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18106  if (!SWIG_IsOK(ecode2)) {
18107  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
18108  }
18109  arg2 = static_cast< ptrdiff_t >(val2);
18110  try {
18111  result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
18112  }
18113  catch(swig::stop_iteration &_e) {
18114  {
18115  (void)_e;
18116  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18117  SWIG_fail;
18118  }
18119  }
18120 
18121  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
18122  return resultobj;
18123 fail:
18124  return NULL;
18125 }
18126 
18127 
18128 SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18129  PyObject *resultobj = 0;
18131  ptrdiff_t arg2 ;
18132  void *argp1 = 0 ;
18133  int res1 = 0 ;
18134  ptrdiff_t val2 ;
18135  int ecode2 = 0 ;
18136  PyObject * obj0 = 0 ;
18137  PyObject * obj1 = 0 ;
18138  swig::SwigPyIterator *result = 0 ;
18139 
18140  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail;
18141  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
18142  if (!SWIG_IsOK(res1)) {
18143  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
18144  }
18145  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
18146  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18147  if (!SWIG_IsOK(ecode2)) {
18148  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
18149  }
18150  arg2 = static_cast< ptrdiff_t >(val2);
18151  try {
18152  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
18153  }
18154  catch(swig::stop_iteration &_e) {
18155  {
18156  (void)_e;
18157  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18158  SWIG_fail;
18159  }
18160  }
18161 
18162  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
18163  return resultobj;
18164 fail:
18165  return NULL;
18166 }
18167 
18168 
18169 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18170  PyObject *resultobj = 0;
18172  ptrdiff_t arg2 ;
18173  void *argp1 = 0 ;
18174  int res1 = 0 ;
18175  ptrdiff_t val2 ;
18176  int ecode2 = 0 ;
18177  PyObject * obj0 = 0 ;
18178  PyObject * obj1 = 0 ;
18179  swig::SwigPyIterator *result = 0 ;
18180 
18181  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
18182  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
18183  if (!SWIG_IsOK(res1)) {
18184  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
18185  }
18186  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
18187  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18188  if (!SWIG_IsOK(ecode2)) {
18189  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
18190  }
18191  arg2 = static_cast< ptrdiff_t >(val2);
18192  try {
18193  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
18194  }
18195  catch(swig::stop_iteration &_e) {
18196  {
18197  (void)_e;
18198  SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
18199  SWIG_fail;
18200  }
18201  }
18202 
18203  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
18204  return resultobj;
18205 fail:
18206  return NULL;
18207 }
18208 
18209 
18210 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18211  PyObject *resultobj = 0;
18213  swig::SwigPyIterator *arg2 = 0 ;
18214  void *argp1 = 0 ;
18215  int res1 = 0 ;
18216  void *argp2 = 0 ;
18217  int res2 = 0 ;
18218  PyObject * obj0 = 0 ;
18219  PyObject * obj1 = 0 ;
18220  ptrdiff_t result;
18221 
18222  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
18223  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
18224  if (!SWIG_IsOK(res1)) {
18225  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
18226  }
18227  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
18228  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
18229  if (!SWIG_IsOK(res2)) {
18230  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
18231  }
18232  if (!argp2) {
18233  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
18234  }
18235  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
18236  result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
18237  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
18238  return resultobj;
18239 fail:
18240  return NULL;
18241 }
18242 
18243 
18244 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
18245  Py_ssize_t argc;
18246  PyObject *argv[3] = {
18247  0
18248  };
18249  Py_ssize_t ii;
18250 
18251  if (!PyTuple_Check(args)) SWIG_fail;
18252  argc = args ? PyObject_Length(args) : 0;
18253  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
18254  argv[ii] = PyTuple_GET_ITEM(args,ii);
18255  }
18256  if (argc == 2) {
18257  int _v;
18258  void *vptr = 0;
18259  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
18260  _v = SWIG_CheckState(res);
18261  if (_v) {
18262  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
18263  _v = SWIG_CheckState(res);
18264  if (_v) {
18265  return _wrap_SwigPyIterator___sub____SWIG_1(self, args);
18266  }
18267  }
18268  }
18269  if (argc == 2) {
18270  int _v;
18271  void *vptr = 0;
18272  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
18273  _v = SWIG_CheckState(res);
18274  if (_v) {
18275  {
18276  int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18277  _v = SWIG_CheckState(res);
18278  }
18279  if (_v) {
18280  return _wrap_SwigPyIterator___sub____SWIG_0(self, args);
18281  }
18282  }
18283  }
18284 
18285 fail:
18286  Py_INCREF(Py_NotImplemented);
18287  return Py_NotImplemented;
18288 }
18289 
18290 
18291 SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18292  PyObject *obj;
18293  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
18294  SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
18295  return SWIG_Py_Void();
18296 }
18297 
18298 SWIGINTERN int Swig_var_ios_base_boolalpha_set(PyObject *) {
18299  SWIG_Error(SWIG_AttributeError,"Variable ios_base_boolalpha is read-only.");
18300  return 1;
18301 }
18302 
18303 
18304 SWIGINTERN PyObject *Swig_var_ios_base_boolalpha_get(void) {
18305  PyObject *pyobj = 0;
18306 
18307  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::boolalpha));
18308  return pyobj;
18309 }
18310 
18311 
18312 SWIGINTERN int Swig_var_ios_base_dec_set(PyObject *) {
18313  SWIG_Error(SWIG_AttributeError,"Variable ios_base_dec is read-only.");
18314  return 1;
18315 }
18316 
18317 
18318 SWIGINTERN PyObject *Swig_var_ios_base_dec_get(void) {
18319  PyObject *pyobj = 0;
18320 
18321  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::dec));
18322  return pyobj;
18323 }
18324 
18325 
18326 SWIGINTERN int Swig_var_ios_base_fixed_set(PyObject *) {
18327  SWIG_Error(SWIG_AttributeError,"Variable ios_base_fixed is read-only.");
18328  return 1;
18329 }
18330 
18331 
18332 SWIGINTERN PyObject *Swig_var_ios_base_fixed_get(void) {
18333  PyObject *pyobj = 0;
18334 
18335  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::fixed));
18336  return pyobj;
18337 }
18338 
18339 
18340 SWIGINTERN int Swig_var_ios_base_hex_set(PyObject *) {
18341  SWIG_Error(SWIG_AttributeError,"Variable ios_base_hex is read-only.");
18342  return 1;
18343 }
18344 
18345 
18346 SWIGINTERN PyObject *Swig_var_ios_base_hex_get(void) {
18347  PyObject *pyobj = 0;
18348 
18349  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::hex));
18350  return pyobj;
18351 }
18352 
18353 
18354 SWIGINTERN int Swig_var_ios_base_internal_set(PyObject *) {
18355  SWIG_Error(SWIG_AttributeError,"Variable ios_base_internal is read-only.");
18356  return 1;
18357 }
18358 
18359 
18360 SWIGINTERN PyObject *Swig_var_ios_base_internal_get(void) {
18361  PyObject *pyobj = 0;
18362 
18363  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::internal));
18364  return pyobj;
18365 }
18366 
18367 
18368 SWIGINTERN int Swig_var_ios_base_left_set(PyObject *) {
18369  SWIG_Error(SWIG_AttributeError,"Variable ios_base_left is read-only.");
18370  return 1;
18371 }
18372 
18373 
18374 SWIGINTERN PyObject *Swig_var_ios_base_left_get(void) {
18375  PyObject *pyobj = 0;
18376 
18377  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::left));
18378  return pyobj;
18379 }
18380 
18381 
18382 SWIGINTERN int Swig_var_ios_base_oct_set(PyObject *) {
18383  SWIG_Error(SWIG_AttributeError,"Variable ios_base_oct is read-only.");
18384  return 1;
18385 }
18386 
18387 
18388 SWIGINTERN PyObject *Swig_var_ios_base_oct_get(void) {
18389  PyObject *pyobj = 0;
18390 
18391  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::oct));
18392  return pyobj;
18393 }
18394 
18395 
18396 SWIGINTERN int Swig_var_ios_base_right_set(PyObject *) {
18397  SWIG_Error(SWIG_AttributeError,"Variable ios_base_right is read-only.");
18398  return 1;
18399 }
18400 
18401 
18402 SWIGINTERN PyObject *Swig_var_ios_base_right_get(void) {
18403  PyObject *pyobj = 0;
18404 
18405  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::right));
18406  return pyobj;
18407 }
18408 
18409 
18410 SWIGINTERN int Swig_var_ios_base_scientific_set(PyObject *) {
18411  SWIG_Error(SWIG_AttributeError,"Variable ios_base_scientific is read-only.");
18412  return 1;
18413 }
18414 
18415 
18416 SWIGINTERN PyObject *Swig_var_ios_base_scientific_get(void) {
18417  PyObject *pyobj = 0;
18418 
18419  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::scientific));
18420  return pyobj;
18421 }
18422 
18423 
18424 SWIGINTERN int Swig_var_ios_base_showbase_set(PyObject *) {
18425  SWIG_Error(SWIG_AttributeError,"Variable ios_base_showbase is read-only.");
18426  return 1;
18427 }
18428 
18429 
18430 SWIGINTERN PyObject *Swig_var_ios_base_showbase_get(void) {
18431  PyObject *pyobj = 0;
18432 
18433  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::showbase));
18434  return pyobj;
18435 }
18436 
18437 
18438 SWIGINTERN int Swig_var_ios_base_showpoint_set(PyObject *) {
18439  SWIG_Error(SWIG_AttributeError,"Variable ios_base_showpoint is read-only.");
18440  return 1;
18441 }
18442 
18443 
18444 SWIGINTERN PyObject *Swig_var_ios_base_showpoint_get(void) {
18445  PyObject *pyobj = 0;
18446 
18447  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::showpoint));
18448  return pyobj;
18449 }
18450 
18451 
18452 SWIGINTERN int Swig_var_ios_base_showpos_set(PyObject *) {
18453  SWIG_Error(SWIG_AttributeError,"Variable ios_base_showpos is read-only.");
18454  return 1;
18455 }
18456 
18457 
18458 SWIGINTERN PyObject *Swig_var_ios_base_showpos_get(void) {
18459  PyObject *pyobj = 0;
18460 
18461  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::showpos));
18462  return pyobj;
18463 }
18464 
18465 
18466 SWIGINTERN int Swig_var_ios_base_skipws_set(PyObject *) {
18467  SWIG_Error(SWIG_AttributeError,"Variable ios_base_skipws is read-only.");
18468  return 1;
18469 }
18470 
18471 
18472 SWIGINTERN PyObject *Swig_var_ios_base_skipws_get(void) {
18473  PyObject *pyobj = 0;
18474 
18475  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::skipws));
18476  return pyobj;
18477 }
18478 
18479 
18480 SWIGINTERN int Swig_var_ios_base_unitbuf_set(PyObject *) {
18481  SWIG_Error(SWIG_AttributeError,"Variable ios_base_unitbuf is read-only.");
18482  return 1;
18483 }
18484 
18485 
18486 SWIGINTERN PyObject *Swig_var_ios_base_unitbuf_get(void) {
18487  PyObject *pyobj = 0;
18488 
18489  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::unitbuf));
18490  return pyobj;
18491 }
18492 
18493 
18494 SWIGINTERN int Swig_var_ios_base_uppercase_set(PyObject *) {
18495  SWIG_Error(SWIG_AttributeError,"Variable ios_base_uppercase is read-only.");
18496  return 1;
18497 }
18498 
18499 
18500 SWIGINTERN PyObject *Swig_var_ios_base_uppercase_get(void) {
18501  PyObject *pyobj = 0;
18502 
18503  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::uppercase));
18504  return pyobj;
18505 }
18506 
18507 
18508 SWIGINTERN int Swig_var_ios_base_adjustfield_set(PyObject *) {
18509  SWIG_Error(SWIG_AttributeError,"Variable ios_base_adjustfield is read-only.");
18510  return 1;
18511 }
18512 
18513 
18514 SWIGINTERN PyObject *Swig_var_ios_base_adjustfield_get(void) {
18515  PyObject *pyobj = 0;
18516 
18517  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::adjustfield));
18518  return pyobj;
18519 }
18520 
18521 
18522 SWIGINTERN int Swig_var_ios_base_basefield_set(PyObject *) {
18523  SWIG_Error(SWIG_AttributeError,"Variable ios_base_basefield is read-only.");
18524  return 1;
18525 }
18526 
18527 
18528 SWIGINTERN PyObject *Swig_var_ios_base_basefield_get(void) {
18529  PyObject *pyobj = 0;
18530 
18531  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::basefield));
18532  return pyobj;
18533 }
18534 
18535 
18536 SWIGINTERN int Swig_var_ios_base_floatfield_set(PyObject *) {
18537  SWIG_Error(SWIG_AttributeError,"Variable ios_base_floatfield is read-only.");
18538  return 1;
18539 }
18540 
18541 
18542 SWIGINTERN PyObject *Swig_var_ios_base_floatfield_get(void) {
18543  PyObject *pyobj = 0;
18544 
18545  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::floatfield));
18546  return pyobj;
18547 }
18548 
18549 
18550 SWIGINTERN int Swig_var_ios_base_badbit_set(PyObject *) {
18551  SWIG_Error(SWIG_AttributeError,"Variable ios_base_badbit is read-only.");
18552  return 1;
18553 }
18554 
18555 
18556 SWIGINTERN PyObject *Swig_var_ios_base_badbit_get(void) {
18557  PyObject *pyobj = 0;
18558 
18559  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::badbit));
18560  return pyobj;
18561 }
18562 
18563 
18564 SWIGINTERN int Swig_var_ios_base_eofbit_set(PyObject *) {
18565  SWIG_Error(SWIG_AttributeError,"Variable ios_base_eofbit is read-only.");
18566  return 1;
18567 }
18568 
18569 
18570 SWIGINTERN PyObject *Swig_var_ios_base_eofbit_get(void) {
18571  PyObject *pyobj = 0;
18572 
18573  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::eofbit));
18574  return pyobj;
18575 }
18576 
18577 
18578 SWIGINTERN int Swig_var_ios_base_failbit_set(PyObject *) {
18579  SWIG_Error(SWIG_AttributeError,"Variable ios_base_failbit is read-only.");
18580  return 1;
18581 }
18582 
18583 
18584 SWIGINTERN PyObject *Swig_var_ios_base_failbit_get(void) {
18585  PyObject *pyobj = 0;
18586 
18587  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::failbit));
18588  return pyobj;
18589 }
18590 
18591 
18592 SWIGINTERN int Swig_var_ios_base_goodbit_set(PyObject *) {
18593  SWIG_Error(SWIG_AttributeError,"Variable ios_base_goodbit is read-only.");
18594  return 1;
18595 }
18596 
18597 
18598 SWIGINTERN PyObject *Swig_var_ios_base_goodbit_get(void) {
18599  PyObject *pyobj = 0;
18600 
18601  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::goodbit));
18602  return pyobj;
18603 }
18604 
18605 
18606 SWIGINTERN int Swig_var_ios_base_app_set(PyObject *) {
18607  SWIG_Error(SWIG_AttributeError,"Variable ios_base_app is read-only.");
18608  return 1;
18609 }
18610 
18611 
18612 SWIGINTERN PyObject *Swig_var_ios_base_app_get(void) {
18613  PyObject *pyobj = 0;
18614 
18615  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::app));
18616  return pyobj;
18617 }
18618 
18619 
18620 SWIGINTERN int Swig_var_ios_base_ate_set(PyObject *) {
18621  SWIG_Error(SWIG_AttributeError,"Variable ios_base_ate is read-only.");
18622  return 1;
18623 }
18624 
18625 
18626 SWIGINTERN PyObject *Swig_var_ios_base_ate_get(void) {
18627  PyObject *pyobj = 0;
18628 
18629  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::ate));
18630  return pyobj;
18631 }
18632 
18633 
18634 SWIGINTERN int Swig_var_ios_base_binary_set(PyObject *) {
18635  SWIG_Error(SWIG_AttributeError,"Variable ios_base_binary is read-only.");
18636  return 1;
18637 }
18638 
18639 
18640 SWIGINTERN PyObject *Swig_var_ios_base_binary_get(void) {
18641  PyObject *pyobj = 0;
18642 
18643  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::binary));
18644  return pyobj;
18645 }
18646 
18647 
18648 SWIGINTERN int Swig_var_ios_base_ios_base_in_set(PyObject *) {
18649  SWIG_Error(SWIG_AttributeError,"Variable ios_base_ios_base_in is read-only.");
18650  return 1;
18651 }
18652 
18653 
18654 SWIGINTERN PyObject *Swig_var_ios_base_ios_base_in_get(void) {
18655  PyObject *pyobj = 0;
18656 
18657  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::in));
18658  return pyobj;
18659 }
18660 
18661 
18662 SWIGINTERN int Swig_var_ios_base_out_set(PyObject *) {
18663  SWIG_Error(SWIG_AttributeError,"Variable ios_base_out is read-only.");
18664  return 1;
18665 }
18666 
18667 
18668 SWIGINTERN PyObject *Swig_var_ios_base_out_get(void) {
18669  PyObject *pyobj = 0;
18670 
18671  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::out));
18672  return pyobj;
18673 }
18674 
18675 
18676 SWIGINTERN int Swig_var_ios_base_trunc_set(PyObject *) {
18677  SWIG_Error(SWIG_AttributeError,"Variable ios_base_trunc is read-only.");
18678  return 1;
18679 }
18680 
18681 
18682 SWIGINTERN PyObject *Swig_var_ios_base_trunc_get(void) {
18683  PyObject *pyobj = 0;
18684 
18685  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::trunc));
18686  return pyobj;
18687 }
18688 
18689 
18690 SWIGINTERN int Swig_var_ios_base_beg_set(PyObject *) {
18691  SWIG_Error(SWIG_AttributeError,"Variable ios_base_beg is read-only.");
18692  return 1;
18693 }
18694 
18695 
18696 SWIGINTERN PyObject *Swig_var_ios_base_beg_get(void) {
18697  PyObject *pyobj = 0;
18698 
18699  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::beg));
18700  return pyobj;
18701 }
18702 
18703 
18704 SWIGINTERN int Swig_var_ios_base_cur_set(PyObject *) {
18705  SWIG_Error(SWIG_AttributeError,"Variable ios_base_cur is read-only.");
18706  return 1;
18707 }
18708 
18709 
18710 SWIGINTERN PyObject *Swig_var_ios_base_cur_get(void) {
18711  PyObject *pyobj = 0;
18712 
18713  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::cur));
18714  return pyobj;
18715 }
18716 
18717 
18718 SWIGINTERN int Swig_var_ios_base_end_set(PyObject *) {
18719  SWIG_Error(SWIG_AttributeError,"Variable ios_base_end is read-only.");
18720  return 1;
18721 }
18722 
18723 
18724 SWIGINTERN PyObject *Swig_var_ios_base_end_get(void) {
18725  PyObject *pyobj = 0;
18726 
18727  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::end));
18728  return pyobj;
18729 }
18730 
18731 
18732 SWIGINTERN PyObject *_wrap_ios_base_register_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18733  PyObject *resultobj = 0;
18734  std::ios_base *arg1 = (std::ios_base *) 0 ;
18735  std::ios_base::event_callback arg2 = (std::ios_base::event_callback) 0 ;
18736  int arg3 ;
18737  void *argp1 = 0 ;
18738  int res1 = 0 ;
18739  int val3 ;
18740  int ecode3 = 0 ;
18741  PyObject * obj0 = 0 ;
18742  PyObject * obj1 = 0 ;
18743  PyObject * obj2 = 0 ;
18744 
18745  if (!PyArg_ParseTuple(args,(char *)"OOO:ios_base_register_callback",&obj0,&obj1,&obj2)) SWIG_fail;
18746  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
18747  if (!SWIG_IsOK(res1)) {
18748  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_register_callback" "', argument " "1"" of type '" "std::ios_base *""'");
18749  }
18750  arg1 = reinterpret_cast< std::ios_base * >(argp1);
18751  {
18752  int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_enum_std__ios_base__event_r_std__ios_base_int__void);
18753  if (!SWIG_IsOK(res)) {
18754  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ios_base_register_callback" "', argument " "2"" of type '" "std::ios_base::event_callback""'");
18755  }
18756  }
18757  ecode3 = SWIG_AsVal_int(obj2, &val3);
18758  if (!SWIG_IsOK(ecode3)) {
18759  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ios_base_register_callback" "', argument " "3"" of type '" "int""'");
18760  }
18761  arg3 = static_cast< int >(val3);
18762  (arg1)->register_callback(arg2,arg3);
18763  resultobj = SWIG_Py_Void();
18764  return resultobj;
18765 fail:
18766  return NULL;
18767 }
18768 
18769 
18770 SWIGINTERN PyObject *_wrap_ios_base_flags__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18771  PyObject *resultobj = 0;
18772  std::ios_base *arg1 = (std::ios_base *) 0 ;
18773  void *argp1 = 0 ;
18774  int res1 = 0 ;
18775  PyObject * obj0 = 0 ;
18776  std::ios_base::fmtflags result;
18777 
18778  if (!PyArg_ParseTuple(args,(char *)"O:ios_base_flags",&obj0)) SWIG_fail;
18779  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
18780  if (!SWIG_IsOK(res1)) {
18781  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_flags" "', argument " "1"" of type '" "std::ios_base const *""'");
18782  }
18783  arg1 = reinterpret_cast< std::ios_base * >(argp1);
18784  result = (std::ios_base::fmtflags)((std::ios_base const *)arg1)->flags();
18785  resultobj = SWIG_From_int(static_cast< int >(result));
18786  return resultobj;
18787 fail:
18788  return NULL;
18789 }
18790 
18791 
18792 SWIGINTERN PyObject *_wrap_ios_base_flags__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18793  PyObject *resultobj = 0;
18794  std::ios_base *arg1 = (std::ios_base *) 0 ;
18795  std::ios_base::fmtflags arg2 ;
18796  void *argp1 = 0 ;
18797  int res1 = 0 ;
18798  int val2 ;
18799  int ecode2 = 0 ;
18800  PyObject * obj0 = 0 ;
18801  PyObject * obj1 = 0 ;
18802  std::ios_base::fmtflags result;
18803 
18804  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_flags",&obj0,&obj1)) SWIG_fail;
18805  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
18806  if (!SWIG_IsOK(res1)) {
18807  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_flags" "', argument " "1"" of type '" "std::ios_base *""'");
18808  }
18809  arg1 = reinterpret_cast< std::ios_base * >(argp1);
18810  ecode2 = SWIG_AsVal_int(obj1, &val2);
18811  if (!SWIG_IsOK(ecode2)) {
18812  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_flags" "', argument " "2"" of type '" "std::ios_base::fmtflags""'");
18813  }
18814  arg2 = static_cast< std::ios_base::fmtflags >(val2);
18815  result = (std::ios_base::fmtflags)(arg1)->flags(arg2);
18816  resultobj = SWIG_From_int(static_cast< int >(result));
18817  return resultobj;
18818 fail:
18819  return NULL;
18820 }
18821 
18822 
18823 SWIGINTERN PyObject *_wrap_ios_base_flags(PyObject *self, PyObject *args) {
18824  Py_ssize_t argc;
18825  PyObject *argv[3] = {
18826  0
18827  };
18828  Py_ssize_t ii;
18829 
18830  if (!PyTuple_Check(args)) SWIG_fail;
18831  argc = args ? PyObject_Length(args) : 0;
18832  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
18833  argv[ii] = PyTuple_GET_ITEM(args,ii);
18834  }
18835  if (argc == 1) {
18836  int _v;
18837  void *vptr = 0;
18838  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
18839  _v = SWIG_CheckState(res);
18840  if (_v) {
18841  return _wrap_ios_base_flags__SWIG_0(self, args);
18842  }
18843  }
18844  if (argc == 2) {
18845  int _v;
18846  void *vptr = 0;
18847  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
18848  _v = SWIG_CheckState(res);
18849  if (_v) {
18850  {
18851  int res = SWIG_AsVal_int(argv[1], NULL);
18852  _v = SWIG_CheckState(res);
18853  }
18854  if (_v) {
18855  return _wrap_ios_base_flags__SWIG_1(self, args);
18856  }
18857  }
18858  }
18859 
18860 fail:
18861  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_base_flags'.\n"
18862  " Possible C/C++ prototypes are:\n"
18863  " std::ios_base::flags() const\n"
18864  " std::ios_base::flags(std::ios_base::fmtflags)\n");
18865  return 0;
18866 }
18867 
18868 
18869 SWIGINTERN PyObject *_wrap_ios_base_setf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18870  PyObject *resultobj = 0;
18871  std::ios_base *arg1 = (std::ios_base *) 0 ;
18872  std::ios_base::fmtflags arg2 ;
18873  void *argp1 = 0 ;
18874  int res1 = 0 ;
18875  int val2 ;
18876  int ecode2 = 0 ;
18877  PyObject * obj0 = 0 ;
18878  PyObject * obj1 = 0 ;
18879  std::ios_base::fmtflags result;
18880 
18881  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_setf",&obj0,&obj1)) SWIG_fail;
18882  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
18883  if (!SWIG_IsOK(res1)) {
18884  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_setf" "', argument " "1"" of type '" "std::ios_base *""'");
18885  }
18886  arg1 = reinterpret_cast< std::ios_base * >(argp1);
18887  ecode2 = SWIG_AsVal_int(obj1, &val2);
18888  if (!SWIG_IsOK(ecode2)) {
18889  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_setf" "', argument " "2"" of type '" "std::ios_base::fmtflags""'");
18890  }
18891  arg2 = static_cast< std::ios_base::fmtflags >(val2);
18892  result = (std::ios_base::fmtflags)(arg1)->setf(arg2);
18893  resultobj = SWIG_From_int(static_cast< int >(result));
18894  return resultobj;
18895 fail:
18896  return NULL;
18897 }
18898 
18899 
18900 SWIGINTERN PyObject *_wrap_ios_base_setf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18901  PyObject *resultobj = 0;
18902  std::ios_base *arg1 = (std::ios_base *) 0 ;
18903  std::ios_base::fmtflags arg2 ;
18904  std::ios_base::fmtflags arg3 ;
18905  void *argp1 = 0 ;
18906  int res1 = 0 ;
18907  int val2 ;
18908  int ecode2 = 0 ;
18909  int val3 ;
18910  int ecode3 = 0 ;
18911  PyObject * obj0 = 0 ;
18912  PyObject * obj1 = 0 ;
18913  PyObject * obj2 = 0 ;
18914  std::ios_base::fmtflags result;
18915 
18916  if (!PyArg_ParseTuple(args,(char *)"OOO:ios_base_setf",&obj0,&obj1,&obj2)) SWIG_fail;
18917  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
18918  if (!SWIG_IsOK(res1)) {
18919  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_setf" "', argument " "1"" of type '" "std::ios_base *""'");
18920  }
18921  arg1 = reinterpret_cast< std::ios_base * >(argp1);
18922  ecode2 = SWIG_AsVal_int(obj1, &val2);
18923  if (!SWIG_IsOK(ecode2)) {
18924  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_setf" "', argument " "2"" of type '" "std::ios_base::fmtflags""'");
18925  }
18926  arg2 = static_cast< std::ios_base::fmtflags >(val2);
18927  ecode3 = SWIG_AsVal_int(obj2, &val3);
18928  if (!SWIG_IsOK(ecode3)) {
18929  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ios_base_setf" "', argument " "3"" of type '" "std::ios_base::fmtflags""'");
18930  }
18931  arg3 = static_cast< std::ios_base::fmtflags >(val3);
18932  result = (std::ios_base::fmtflags)(arg1)->setf(arg2,arg3);
18933  resultobj = SWIG_From_int(static_cast< int >(result));
18934  return resultobj;
18935 fail:
18936  return NULL;
18937 }
18938 
18939 
18940 SWIGINTERN PyObject *_wrap_ios_base_setf(PyObject *self, PyObject *args) {
18941  Py_ssize_t argc;
18942  PyObject *argv[4] = {
18943  0
18944  };
18945  Py_ssize_t ii;
18946 
18947  if (!PyTuple_Check(args)) SWIG_fail;
18948  argc = args ? PyObject_Length(args) : 0;
18949  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
18950  argv[ii] = PyTuple_GET_ITEM(args,ii);
18951  }
18952  if (argc == 2) {
18953  int _v;
18954  void *vptr = 0;
18955  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
18956  _v = SWIG_CheckState(res);
18957  if (_v) {
18958  {
18959  int res = SWIG_AsVal_int(argv[1], NULL);
18960  _v = SWIG_CheckState(res);
18961  }
18962  if (_v) {
18963  return _wrap_ios_base_setf__SWIG_0(self, args);
18964  }
18965  }
18966  }
18967  if (argc == 3) {
18968  int _v;
18969  void *vptr = 0;
18970  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
18971  _v = SWIG_CheckState(res);
18972  if (_v) {
18973  {
18974  int res = SWIG_AsVal_int(argv[1], NULL);
18975  _v = SWIG_CheckState(res);
18976  }
18977  if (_v) {
18978  {
18979  int res = SWIG_AsVal_int(argv[2], NULL);
18980  _v = SWIG_CheckState(res);
18981  }
18982  if (_v) {
18983  return _wrap_ios_base_setf__SWIG_1(self, args);
18984  }
18985  }
18986  }
18987  }
18988 
18989 fail:
18990  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_base_setf'.\n"
18991  " Possible C/C++ prototypes are:\n"
18992  " std::ios_base::setf(std::ios_base::fmtflags)\n"
18993  " std::ios_base::setf(std::ios_base::fmtflags,std::ios_base::fmtflags)\n");
18994  return 0;
18995 }
18996 
18997 
18998 SWIGINTERN PyObject *_wrap_ios_base_unsetf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18999  PyObject *resultobj = 0;
19000  std::ios_base *arg1 = (std::ios_base *) 0 ;
19001  std::ios_base::fmtflags arg2 ;
19002  void *argp1 = 0 ;
19003  int res1 = 0 ;
19004  int val2 ;
19005  int ecode2 = 0 ;
19006  PyObject * obj0 = 0 ;
19007  PyObject * obj1 = 0 ;
19008 
19009  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_unsetf",&obj0,&obj1)) SWIG_fail;
19010  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
19011  if (!SWIG_IsOK(res1)) {
19012  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_unsetf" "', argument " "1"" of type '" "std::ios_base *""'");
19013  }
19014  arg1 = reinterpret_cast< std::ios_base * >(argp1);
19015  ecode2 = SWIG_AsVal_int(obj1, &val2);
19016  if (!SWIG_IsOK(ecode2)) {
19017  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_unsetf" "', argument " "2"" of type '" "std::ios_base::fmtflags""'");
19018  }
19019  arg2 = static_cast< std::ios_base::fmtflags >(val2);
19020  (arg1)->unsetf(arg2);
19021  resultobj = SWIG_Py_Void();
19022  return resultobj;
19023 fail:
19024  return NULL;
19025 }
19026 
19027 
19028 SWIGINTERN PyObject *_wrap_ios_base_precision__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19029  PyObject *resultobj = 0;
19030  std::ios_base *arg1 = (std::ios_base *) 0 ;
19031  void *argp1 = 0 ;
19032  int res1 = 0 ;
19033  PyObject * obj0 = 0 ;
19034  std::streamsize result;
19035 
19036  if (!PyArg_ParseTuple(args,(char *)"O:ios_base_precision",&obj0)) SWIG_fail;
19037  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
19038  if (!SWIG_IsOK(res1)) {
19039  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_precision" "', argument " "1"" of type '" "std::ios_base const *""'");
19040  }
19041  arg1 = reinterpret_cast< std::ios_base * >(argp1);
19042  result = ((std::ios_base const *)arg1)->precision();
19043  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19044  return resultobj;
19045 fail:
19046  return NULL;
19047 }
19048 
19049 
19050 SWIGINTERN PyObject *_wrap_ios_base_precision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19051  PyObject *resultobj = 0;
19052  std::ios_base *arg1 = (std::ios_base *) 0 ;
19053  std::streamsize arg2 ;
19054  void *argp1 = 0 ;
19055  int res1 = 0 ;
19056  size_t val2 ;
19057  int ecode2 = 0 ;
19058  PyObject * obj0 = 0 ;
19059  PyObject * obj1 = 0 ;
19060  std::streamsize result;
19061 
19062  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_precision",&obj0,&obj1)) SWIG_fail;
19063  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
19064  if (!SWIG_IsOK(res1)) {
19065  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_precision" "', argument " "1"" of type '" "std::ios_base *""'");
19066  }
19067  arg1 = reinterpret_cast< std::ios_base * >(argp1);
19068  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19069  if (!SWIG_IsOK(ecode2)) {
19070  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_precision" "', argument " "2"" of type '" "std::streamsize""'");
19071  }
19072  arg2 = static_cast< std::streamsize >(val2);
19073  result = (arg1)->precision(arg2);
19074  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19075  return resultobj;
19076 fail:
19077  return NULL;
19078 }
19079 
19080 
19081 SWIGINTERN PyObject *_wrap_ios_base_precision(PyObject *self, PyObject *args) {
19082  Py_ssize_t argc;
19083  PyObject *argv[3] = {
19084  0
19085  };
19086  Py_ssize_t ii;
19087 
19088  if (!PyTuple_Check(args)) SWIG_fail;
19089  argc = args ? PyObject_Length(args) : 0;
19090  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
19091  argv[ii] = PyTuple_GET_ITEM(args,ii);
19092  }
19093  if (argc == 1) {
19094  int _v;
19095  void *vptr = 0;
19096  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
19097  _v = SWIG_CheckState(res);
19098  if (_v) {
19099  return _wrap_ios_base_precision__SWIG_0(self, args);
19100  }
19101  }
19102  if (argc == 2) {
19103  int _v;
19104  void *vptr = 0;
19105  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
19106  _v = SWIG_CheckState(res);
19107  if (_v) {
19108  {
19109  int res = SWIG_AsVal_size_t(argv[1], NULL);
19110  _v = SWIG_CheckState(res);
19111  }
19112  if (_v) {
19113  return _wrap_ios_base_precision__SWIG_1(self, args);
19114  }
19115  }
19116  }
19117 
19118 fail:
19119  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_base_precision'.\n"
19120  " Possible C/C++ prototypes are:\n"
19121  " std::ios_base::precision() const\n"
19122  " std::ios_base::precision(std::streamsize)\n");
19123  return 0;
19124 }
19125 
19126 
19127 SWIGINTERN PyObject *_wrap_ios_base_width__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19128  PyObject *resultobj = 0;
19129  std::ios_base *arg1 = (std::ios_base *) 0 ;
19130  void *argp1 = 0 ;
19131  int res1 = 0 ;
19132  PyObject * obj0 = 0 ;
19133  std::streamsize result;
19134 
19135  if (!PyArg_ParseTuple(args,(char *)"O:ios_base_width",&obj0)) SWIG_fail;
19136  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
19137  if (!SWIG_IsOK(res1)) {
19138  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_width" "', argument " "1"" of type '" "std::ios_base const *""'");
19139  }
19140  arg1 = reinterpret_cast< std::ios_base * >(argp1);
19141  result = ((std::ios_base const *)arg1)->width();
19142  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19143  return resultobj;
19144 fail:
19145  return NULL;
19146 }
19147 
19148 
19149 SWIGINTERN PyObject *_wrap_ios_base_width__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19150  PyObject *resultobj = 0;
19151  std::ios_base *arg1 = (std::ios_base *) 0 ;
19152  std::streamsize arg2 ;
19153  void *argp1 = 0 ;
19154  int res1 = 0 ;
19155  size_t val2 ;
19156  int ecode2 = 0 ;
19157  PyObject * obj0 = 0 ;
19158  PyObject * obj1 = 0 ;
19159  std::streamsize result;
19160 
19161  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_width",&obj0,&obj1)) SWIG_fail;
19162  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
19163  if (!SWIG_IsOK(res1)) {
19164  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_width" "', argument " "1"" of type '" "std::ios_base *""'");
19165  }
19166  arg1 = reinterpret_cast< std::ios_base * >(argp1);
19167  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19168  if (!SWIG_IsOK(ecode2)) {
19169  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_width" "', argument " "2"" of type '" "std::streamsize""'");
19170  }
19171  arg2 = static_cast< std::streamsize >(val2);
19172  result = (arg1)->width(arg2);
19173  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19174  return resultobj;
19175 fail:
19176  return NULL;
19177 }
19178 
19179 
19180 SWIGINTERN PyObject *_wrap_ios_base_width(PyObject *self, PyObject *args) {
19181  Py_ssize_t argc;
19182  PyObject *argv[3] = {
19183  0
19184  };
19185  Py_ssize_t ii;
19186 
19187  if (!PyTuple_Check(args)) SWIG_fail;
19188  argc = args ? PyObject_Length(args) : 0;
19189  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
19190  argv[ii] = PyTuple_GET_ITEM(args,ii);
19191  }
19192  if (argc == 1) {
19193  int _v;
19194  void *vptr = 0;
19195  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
19196  _v = SWIG_CheckState(res);
19197  if (_v) {
19198  return _wrap_ios_base_width__SWIG_0(self, args);
19199  }
19200  }
19201  if (argc == 2) {
19202  int _v;
19203  void *vptr = 0;
19204  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
19205  _v = SWIG_CheckState(res);
19206  if (_v) {
19207  {
19208  int res = SWIG_AsVal_size_t(argv[1], NULL);
19209  _v = SWIG_CheckState(res);
19210  }
19211  if (_v) {
19212  return _wrap_ios_base_width__SWIG_1(self, args);
19213  }
19214  }
19215  }
19216 
19217 fail:
19218  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_base_width'.\n"
19219  " Possible C/C++ prototypes are:\n"
19220  " std::ios_base::width() const\n"
19221  " std::ios_base::width(std::streamsize)\n");
19222  return 0;
19223 }
19224 
19225 
19226 SWIGINTERN PyObject *_wrap_ios_base_sync_with_stdio__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19227  PyObject *resultobj = 0;
19228  bool arg1 ;
19229  bool val1 ;
19230  int ecode1 = 0 ;
19231  PyObject * obj0 = 0 ;
19232  bool result;
19233 
19234  if (!PyArg_ParseTuple(args,(char *)"O:ios_base_sync_with_stdio",&obj0)) SWIG_fail;
19235  ecode1 = SWIG_AsVal_bool(obj0, &val1);
19236  if (!SWIG_IsOK(ecode1)) {
19237  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ios_base_sync_with_stdio" "', argument " "1"" of type '" "bool""'");
19238  }
19239  arg1 = static_cast< bool >(val1);
19240  result = (bool)std::ios_base::sync_with_stdio(arg1);
19241  resultobj = SWIG_From_bool(static_cast< bool >(result));
19242  return resultobj;
19243 fail:
19244  return NULL;
19245 }
19246 
19247 
19248 SWIGINTERN PyObject *_wrap_ios_base_sync_with_stdio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19249  PyObject *resultobj = 0;
19250  bool result;
19251 
19252  if (!PyArg_ParseTuple(args,(char *)":ios_base_sync_with_stdio")) SWIG_fail;
19253  result = (bool)std::ios_base::sync_with_stdio();
19254  resultobj = SWIG_From_bool(static_cast< bool >(result));
19255  return resultobj;
19256 fail:
19257  return NULL;
19258 }
19259 
19260 
19261 SWIGINTERN PyObject *_wrap_ios_base_sync_with_stdio(PyObject *self, PyObject *args) {
19262  Py_ssize_t argc;
19263  PyObject *argv[2] = {
19264  0
19265  };
19266  Py_ssize_t ii;
19267 
19268  if (!PyTuple_Check(args)) SWIG_fail;
19269  argc = args ? PyObject_Length(args) : 0;
19270  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
19271  argv[ii] = PyTuple_GET_ITEM(args,ii);
19272  }
19273  if (argc == 0) {
19274  return _wrap_ios_base_sync_with_stdio__SWIG_1(self, args);
19275  }
19276  if (argc == 1) {
19277  int _v;
19278  {
19279  int res = SWIG_AsVal_bool(argv[0], NULL);
19280  _v = SWIG_CheckState(res);
19281  }
19282  if (_v) {
19283  return _wrap_ios_base_sync_with_stdio__SWIG_0(self, args);
19284  }
19285  }
19286 
19287 fail:
19288  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_base_sync_with_stdio'.\n"
19289  " Possible C/C++ prototypes are:\n"
19290  " std::ios_base::sync_with_stdio(bool)\n"
19291  " std::ios_base::sync_with_stdio()\n");
19292  return 0;
19293 }
19294 
19295 
19296 SWIGINTERN PyObject *_wrap_ios_base_imbue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19297  PyObject *resultobj = 0;
19298  std::ios_base *arg1 = (std::ios_base *) 0 ;
19299  std::locale *arg2 = 0 ;
19300  void *argp1 = 0 ;
19301  int res1 = 0 ;
19302  void *argp2 = 0 ;
19303  int res2 = 0 ;
19304  PyObject * obj0 = 0 ;
19305  PyObject * obj1 = 0 ;
19306  std::locale result;
19307 
19308  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_imbue",&obj0,&obj1)) SWIG_fail;
19309  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
19310  if (!SWIG_IsOK(res1)) {
19311  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_imbue" "', argument " "1"" of type '" "std::ios_base *""'");
19312  }
19313  arg1 = reinterpret_cast< std::ios_base * >(argp1);
19314  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__locale, 0 | 0);
19315  if (!SWIG_IsOK(res2)) {
19316  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ios_base_imbue" "', argument " "2"" of type '" "std::locale const &""'");
19317  }
19318  if (!argp2) {
19319  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ios_base_imbue" "', argument " "2"" of type '" "std::locale const &""'");
19320  }
19321  arg2 = reinterpret_cast< std::locale * >(argp2);
19322  result = (arg1)->imbue((std::locale const &)*arg2);
19323  resultobj = SWIG_NewPointerObj((new std::locale(static_cast< const std::locale& >(result))), SWIGTYPE_p_std__locale, SWIG_POINTER_OWN | 0 );
19324  return resultobj;
19325 fail:
19326  return NULL;
19327 }
19328 
19329 
19330 SWIGINTERN PyObject *_wrap_ios_base_getloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19331  PyObject *resultobj = 0;
19332  std::ios_base *arg1 = (std::ios_base *) 0 ;
19333  void *argp1 = 0 ;
19334  int res1 = 0 ;
19335  PyObject * obj0 = 0 ;
19336  std::locale result;
19337 
19338  if (!PyArg_ParseTuple(args,(char *)"O:ios_base_getloc",&obj0)) SWIG_fail;
19339  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
19340  if (!SWIG_IsOK(res1)) {
19341  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_getloc" "', argument " "1"" of type '" "std::ios_base const *""'");
19342  }
19343  arg1 = reinterpret_cast< std::ios_base * >(argp1);
19344  result = ((std::ios_base const *)arg1)->getloc();
19345  resultobj = SWIG_NewPointerObj((new std::locale(static_cast< const std::locale& >(result))), SWIGTYPE_p_std__locale, SWIG_POINTER_OWN | 0 );
19346  return resultobj;
19347 fail:
19348  return NULL;
19349 }
19350 
19351 
19352 SWIGINTERN PyObject *_wrap_ios_base_xalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19353  PyObject *resultobj = 0;
19354  int result;
19355 
19356  if (!PyArg_ParseTuple(args,(char *)":ios_base_xalloc")) SWIG_fail;
19357  result = (int)std::ios_base::xalloc();
19358  resultobj = SWIG_From_int(static_cast< int >(result));
19359  return resultobj;
19360 fail:
19361  return NULL;
19362 }
19363 
19364 
19365 SWIGINTERN PyObject *_wrap_ios_base_iword(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19366  PyObject *resultobj = 0;
19367  std::ios_base *arg1 = (std::ios_base *) 0 ;
19368  int arg2 ;
19369  void *argp1 = 0 ;
19370  int res1 = 0 ;
19371  int val2 ;
19372  int ecode2 = 0 ;
19373  PyObject * obj0 = 0 ;
19374  PyObject * obj1 = 0 ;
19375  long *result = 0 ;
19376 
19377  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_iword",&obj0,&obj1)) SWIG_fail;
19378  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
19379  if (!SWIG_IsOK(res1)) {
19380  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_iword" "', argument " "1"" of type '" "std::ios_base *""'");
19381  }
19382  arg1 = reinterpret_cast< std::ios_base * >(argp1);
19383  ecode2 = SWIG_AsVal_int(obj1, &val2);
19384  if (!SWIG_IsOK(ecode2)) {
19385  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_iword" "', argument " "2"" of type '" "int""'");
19386  }
19387  arg2 = static_cast< int >(val2);
19388  result = (long *) &(arg1)->iword(arg2);
19389  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_long, 0 | 0 );
19390  return resultobj;
19391 fail:
19392  return NULL;
19393 }
19394 
19395 
19396 SWIGINTERN PyObject *_wrap_ios_base_pword(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19397  PyObject *resultobj = 0;
19398  std::ios_base *arg1 = (std::ios_base *) 0 ;
19399  int arg2 ;
19400  void *argp1 = 0 ;
19401  int res1 = 0 ;
19402  int val2 ;
19403  int ecode2 = 0 ;
19404  PyObject * obj0 = 0 ;
19405  PyObject * obj1 = 0 ;
19406  void **result = 0 ;
19407 
19408  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_pword",&obj0,&obj1)) SWIG_fail;
19409  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 | 0 );
19410  if (!SWIG_IsOK(res1)) {
19411  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_pword" "', argument " "1"" of type '" "std::ios_base *""'");
19412  }
19413  arg1 = reinterpret_cast< std::ios_base * >(argp1);
19414  ecode2 = SWIG_AsVal_int(obj1, &val2);
19415  if (!SWIG_IsOK(ecode2)) {
19416  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_pword" "', argument " "2"" of type '" "int""'");
19417  }
19418  arg2 = static_cast< int >(val2);
19419  result = (void **) &(arg1)->pword(arg2);
19420  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 | 0 );
19421  return resultobj;
19422 fail:
19423  return NULL;
19424 }
19425 
19426 
19427 SWIGINTERN PyObject *_wrap_delete_ios_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19428  PyObject *resultobj = 0;
19429  std::ios_base *arg1 = (std::ios_base *) 0 ;
19430  void *argp1 = 0 ;
19431  int res1 = 0 ;
19432  PyObject * obj0 = 0 ;
19433 
19434  if (!PyArg_ParseTuple(args,(char *)"O:delete_ios_base",&obj0)) SWIG_fail;
19435  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, SWIG_POINTER_DISOWN | 0 );
19436  if (!SWIG_IsOK(res1)) {
19437  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ios_base" "', argument " "1"" of type '" "std::ios_base *""'");
19438  }
19439  arg1 = reinterpret_cast< std::ios_base * >(argp1);
19440  delete arg1;
19441  resultobj = SWIG_Py_Void();
19442  return resultobj;
19443 fail:
19444  return NULL;
19445 }
19446 
19447 
19448 SWIGINTERN PyObject *ios_base_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19449  PyObject *obj;
19450  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
19451  SWIG_TypeNewClientData(SWIGTYPE_p_std__ios_base, SWIG_NewClientData(obj));
19452  return SWIG_Py_Void();
19453 }
19454 
19455 SWIGINTERN PyObject *_wrap_ios_rdstate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19456  PyObject *resultobj = 0;
19457  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19458  void *argp1 = 0 ;
19459  int res1 = 0 ;
19460  PyObject * obj0 = 0 ;
19461  std::ios_base::iostate result;
19462 
19463  if (!PyArg_ParseTuple(args,(char *)"O:ios_rdstate",&obj0)) SWIG_fail;
19464  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19465  if (!SWIG_IsOK(res1)) {
19466  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_rdstate" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
19467  }
19468  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19469  result = (std::ios_base::iostate)((std::basic_ios< char > const *)arg1)->rdstate();
19470  resultobj = SWIG_From_int(static_cast< int >(result));
19471  return resultobj;
19472 fail:
19473  return NULL;
19474 }
19475 
19476 
19477 SWIGINTERN PyObject *_wrap_ios_clear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19478  PyObject *resultobj = 0;
19479  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19480  std::ios_base::iostate arg2 ;
19481  void *argp1 = 0 ;
19482  int res1 = 0 ;
19483  int val2 ;
19484  int ecode2 = 0 ;
19485  PyObject * obj0 = 0 ;
19486  PyObject * obj1 = 0 ;
19487 
19488  if (!PyArg_ParseTuple(args,(char *)"OO:ios_clear",&obj0,&obj1)) SWIG_fail;
19489  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19490  if (!SWIG_IsOK(res1)) {
19491  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_clear" "', argument " "1"" of type '" "std::basic_ios< char > *""'");
19492  }
19493  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19494  ecode2 = SWIG_AsVal_int(obj1, &val2);
19495  if (!SWIG_IsOK(ecode2)) {
19496  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_clear" "', argument " "2"" of type '" "std::ios_base::iostate""'");
19497  }
19498  arg2 = static_cast< std::ios_base::iostate >(val2);
19499  (arg1)->clear(arg2);
19500  resultobj = SWIG_Py_Void();
19501  return resultobj;
19502 fail:
19503  return NULL;
19504 }
19505 
19506 
19507 SWIGINTERN PyObject *_wrap_ios_clear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19508  PyObject *resultobj = 0;
19509  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19510  void *argp1 = 0 ;
19511  int res1 = 0 ;
19512  PyObject * obj0 = 0 ;
19513 
19514  if (!PyArg_ParseTuple(args,(char *)"O:ios_clear",&obj0)) SWIG_fail;
19515  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19516  if (!SWIG_IsOK(res1)) {
19517  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_clear" "', argument " "1"" of type '" "std::basic_ios< char > *""'");
19518  }
19519  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19520  (arg1)->clear();
19521  resultobj = SWIG_Py_Void();
19522  return resultobj;
19523 fail:
19524  return NULL;
19525 }
19526 
19527 
19528 SWIGINTERN PyObject *_wrap_ios_clear(PyObject *self, PyObject *args) {
19529  Py_ssize_t argc;
19530  PyObject *argv[3] = {
19531  0
19532  };
19533  Py_ssize_t ii;
19534 
19535  if (!PyTuple_Check(args)) SWIG_fail;
19536  argc = args ? PyObject_Length(args) : 0;
19537  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
19538  argv[ii] = PyTuple_GET_ITEM(args,ii);
19539  }
19540  if (argc == 1) {
19541  int _v;
19542  void *vptr = 0;
19543  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
19544  _v = SWIG_CheckState(res);
19545  if (_v) {
19546  return _wrap_ios_clear__SWIG_1(self, args);
19547  }
19548  }
19549  if (argc == 2) {
19550  int _v;
19551  void *vptr = 0;
19552  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
19553  _v = SWIG_CheckState(res);
19554  if (_v) {
19555  {
19556  int res = SWIG_AsVal_int(argv[1], NULL);
19557  _v = SWIG_CheckState(res);
19558  }
19559  if (_v) {
19560  return _wrap_ios_clear__SWIG_0(self, args);
19561  }
19562  }
19563  }
19564 
19565 fail:
19566  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_clear'.\n"
19567  " Possible C/C++ prototypes are:\n"
19568  " std::basic_ios< char >::clear(std::ios_base::iostate)\n"
19569  " std::basic_ios< char >::clear()\n");
19570  return 0;
19571 }
19572 
19573 
19574 SWIGINTERN PyObject *_wrap_ios_setstate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19575  PyObject *resultobj = 0;
19576  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19577  std::ios_base::iostate arg2 ;
19578  void *argp1 = 0 ;
19579  int res1 = 0 ;
19580  int val2 ;
19581  int ecode2 = 0 ;
19582  PyObject * obj0 = 0 ;
19583  PyObject * obj1 = 0 ;
19584 
19585  if (!PyArg_ParseTuple(args,(char *)"OO:ios_setstate",&obj0,&obj1)) SWIG_fail;
19586  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19587  if (!SWIG_IsOK(res1)) {
19588  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_setstate" "', argument " "1"" of type '" "std::basic_ios< char > *""'");
19589  }
19590  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19591  ecode2 = SWIG_AsVal_int(obj1, &val2);
19592  if (!SWIG_IsOK(ecode2)) {
19593  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_setstate" "', argument " "2"" of type '" "std::ios_base::iostate""'");
19594  }
19595  arg2 = static_cast< std::ios_base::iostate >(val2);
19596  (arg1)->setstate(arg2);
19597  resultobj = SWIG_Py_Void();
19598  return resultobj;
19599 fail:
19600  return NULL;
19601 }
19602 
19603 
19604 SWIGINTERN PyObject *_wrap_ios_good(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19605  PyObject *resultobj = 0;
19606  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19607  void *argp1 = 0 ;
19608  int res1 = 0 ;
19609  PyObject * obj0 = 0 ;
19610  bool result;
19611 
19612  if (!PyArg_ParseTuple(args,(char *)"O:ios_good",&obj0)) SWIG_fail;
19613  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19614  if (!SWIG_IsOK(res1)) {
19615  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_good" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
19616  }
19617  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19618  result = (bool)((std::basic_ios< char > const *)arg1)->good();
19619  resultobj = SWIG_From_bool(static_cast< bool >(result));
19620  return resultobj;
19621 fail:
19622  return NULL;
19623 }
19624 
19625 
19626 SWIGINTERN PyObject *_wrap_ios_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19627  PyObject *resultobj = 0;
19628  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19629  void *argp1 = 0 ;
19630  int res1 = 0 ;
19631  PyObject * obj0 = 0 ;
19632  bool result;
19633 
19634  if (!PyArg_ParseTuple(args,(char *)"O:ios_eof",&obj0)) SWIG_fail;
19635  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19636  if (!SWIG_IsOK(res1)) {
19637  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_eof" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
19638  }
19639  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19640  result = (bool)((std::basic_ios< char > const *)arg1)->eof();
19641  resultobj = SWIG_From_bool(static_cast< bool >(result));
19642  return resultobj;
19643 fail:
19644  return NULL;
19645 }
19646 
19647 
19648 SWIGINTERN PyObject *_wrap_ios_fail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19649  PyObject *resultobj = 0;
19650  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19651  void *argp1 = 0 ;
19652  int res1 = 0 ;
19653  PyObject * obj0 = 0 ;
19654  bool result;
19655 
19656  if (!PyArg_ParseTuple(args,(char *)"O:ios_fail",&obj0)) SWIG_fail;
19657  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19658  if (!SWIG_IsOK(res1)) {
19659  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_fail" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
19660  }
19661  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19662  result = (bool)((std::basic_ios< char > const *)arg1)->fail();
19663  resultobj = SWIG_From_bool(static_cast< bool >(result));
19664  return resultobj;
19665 fail:
19666  return NULL;
19667 }
19668 
19669 
19670 SWIGINTERN PyObject *_wrap_ios_bad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19671  PyObject *resultobj = 0;
19672  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19673  void *argp1 = 0 ;
19674  int res1 = 0 ;
19675  PyObject * obj0 = 0 ;
19676  bool result;
19677 
19678  if (!PyArg_ParseTuple(args,(char *)"O:ios_bad",&obj0)) SWIG_fail;
19679  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19680  if (!SWIG_IsOK(res1)) {
19681  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_bad" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
19682  }
19683  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19684  result = (bool)((std::basic_ios< char > const *)arg1)->bad();
19685  resultobj = SWIG_From_bool(static_cast< bool >(result));
19686  return resultobj;
19687 fail:
19688  return NULL;
19689 }
19690 
19691 
19692 SWIGINTERN PyObject *_wrap_ios_exceptions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19693  PyObject *resultobj = 0;
19694  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19695  void *argp1 = 0 ;
19696  int res1 = 0 ;
19697  PyObject * obj0 = 0 ;
19698  std::ios_base::iostate result;
19699 
19700  if (!PyArg_ParseTuple(args,(char *)"O:ios_exceptions",&obj0)) SWIG_fail;
19701  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19702  if (!SWIG_IsOK(res1)) {
19703  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_exceptions" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
19704  }
19705  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19706  result = (std::ios_base::iostate)((std::basic_ios< char > const *)arg1)->exceptions();
19707  resultobj = SWIG_From_int(static_cast< int >(result));
19708  return resultobj;
19709 fail:
19710  return NULL;
19711 }
19712 
19713 
19714 SWIGINTERN PyObject *_wrap_ios_exceptions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19715  PyObject *resultobj = 0;
19716  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19717  std::ios_base::iostate arg2 ;
19718  void *argp1 = 0 ;
19719  int res1 = 0 ;
19720  int val2 ;
19721  int ecode2 = 0 ;
19722  PyObject * obj0 = 0 ;
19723  PyObject * obj1 = 0 ;
19724 
19725  if (!PyArg_ParseTuple(args,(char *)"OO:ios_exceptions",&obj0,&obj1)) SWIG_fail;
19726  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19727  if (!SWIG_IsOK(res1)) {
19728  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_exceptions" "', argument " "1"" of type '" "std::basic_ios< char > *""'");
19729  }
19730  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19731  ecode2 = SWIG_AsVal_int(obj1, &val2);
19732  if (!SWIG_IsOK(ecode2)) {
19733  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_exceptions" "', argument " "2"" of type '" "std::ios_base::iostate""'");
19734  }
19735  arg2 = static_cast< std::ios_base::iostate >(val2);
19736  (arg1)->exceptions(arg2);
19737  resultobj = SWIG_Py_Void();
19738  return resultobj;
19739 fail:
19740  return NULL;
19741 }
19742 
19743 
19744 SWIGINTERN PyObject *_wrap_ios_exceptions(PyObject *self, PyObject *args) {
19745  Py_ssize_t argc;
19746  PyObject *argv[3] = {
19747  0
19748  };
19749  Py_ssize_t ii;
19750 
19751  if (!PyTuple_Check(args)) SWIG_fail;
19752  argc = args ? PyObject_Length(args) : 0;
19753  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
19754  argv[ii] = PyTuple_GET_ITEM(args,ii);
19755  }
19756  if (argc == 1) {
19757  int _v;
19758  void *vptr = 0;
19759  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
19760  _v = SWIG_CheckState(res);
19761  if (_v) {
19762  return _wrap_ios_exceptions__SWIG_0(self, args);
19763  }
19764  }
19765  if (argc == 2) {
19766  int _v;
19767  void *vptr = 0;
19768  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
19769  _v = SWIG_CheckState(res);
19770  if (_v) {
19771  {
19772  int res = SWIG_AsVal_int(argv[1], NULL);
19773  _v = SWIG_CheckState(res);
19774  }
19775  if (_v) {
19776  return _wrap_ios_exceptions__SWIG_1(self, args);
19777  }
19778  }
19779  }
19780 
19781 fail:
19782  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_exceptions'.\n"
19783  " Possible C/C++ prototypes are:\n"
19784  " std::basic_ios< char >::exceptions() const\n"
19785  " std::basic_ios< char >::exceptions(std::ios_base::iostate)\n");
19786  return 0;
19787 }
19788 
19789 
19790 SWIGINTERN PyObject *_wrap_new_ios(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19791  PyObject *resultobj = 0;
19792  std::basic_streambuf< char,std::char_traits< char > > *arg1 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
19793  void *argp1 = 0 ;
19794  int res1 = 0 ;
19795  PyObject * obj0 = 0 ;
19796  std::basic_ios< char > *result = 0 ;
19797 
19798  if (!PyArg_ParseTuple(args,(char *)"O:new_ios",&obj0)) SWIG_fail;
19799  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
19800  if (!SWIG_IsOK(res1)) {
19801  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ios" "', argument " "1"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'");
19802  }
19803  arg1 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp1);
19804  result = (std::basic_ios< char > *)new std::basic_ios< char >(arg1);
19805  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NEW | 0 );
19806  return resultobj;
19807 fail:
19808  return NULL;
19809 }
19810 
19811 
19812 SWIGINTERN PyObject *_wrap_delete_ios(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19813  PyObject *resultobj = 0;
19814  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19815  void *argp1 = 0 ;
19816  int res1 = 0 ;
19817  PyObject * obj0 = 0 ;
19818 
19819  if (!PyArg_ParseTuple(args,(char *)"O:delete_ios",&obj0)) SWIG_fail;
19820  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN | 0 );
19821  if (!SWIG_IsOK(res1)) {
19822  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ios" "', argument " "1"" of type '" "std::basic_ios< char > *""'");
19823  }
19824  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19825  delete arg1;
19826  resultobj = SWIG_Py_Void();
19827  return resultobj;
19828 fail:
19829  return NULL;
19830 }
19831 
19832 
19833 SWIGINTERN PyObject *_wrap_ios_tie__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19834  PyObject *resultobj = 0;
19835  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19836  void *argp1 = 0 ;
19837  int res1 = 0 ;
19838  PyObject * obj0 = 0 ;
19839  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
19840 
19841  if (!PyArg_ParseTuple(args,(char *)"O:ios_tie",&obj0)) SWIG_fail;
19842  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19843  if (!SWIG_IsOK(res1)) {
19844  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_tie" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
19845  }
19846  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19847  result = (std::basic_ostream< char,std::char_traits< char > > *)((std::basic_ios< char > const *)arg1)->tie();
19848  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
19849  return resultobj;
19850 fail:
19851  return NULL;
19852 }
19853 
19854 
19855 SWIGINTERN PyObject *_wrap_ios_tie__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19856  PyObject *resultobj = 0;
19857  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19858  std::basic_ostream< char,std::char_traits< char > > *arg2 = (std::basic_ostream< char,std::char_traits< char > > *) 0 ;
19859  void *argp1 = 0 ;
19860  int res1 = 0 ;
19861  void *argp2 = 0 ;
19862  int res2 = 0 ;
19863  PyObject * obj0 = 0 ;
19864  PyObject * obj1 = 0 ;
19865  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
19866 
19867  if (!PyArg_ParseTuple(args,(char *)"OO:ios_tie",&obj0,&obj1)) SWIG_fail;
19868  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19869  if (!SWIG_IsOK(res1)) {
19870  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_tie" "', argument " "1"" of type '" "std::basic_ios< char > *""'");
19871  }
19872  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19873  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
19874  if (!SWIG_IsOK(res2)) {
19875  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ios_tie" "', argument " "2"" of type '" "std::basic_ostream< char,std::char_traits< char > > *""'");
19876  }
19877  arg2 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp2);
19878  result = (std::basic_ostream< char,std::char_traits< char > > *)(arg1)->tie(arg2);
19879  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
19880  return resultobj;
19881 fail:
19882  return NULL;
19883 }
19884 
19885 
19886 SWIGINTERN PyObject *_wrap_ios_tie(PyObject *self, PyObject *args) {
19887  Py_ssize_t argc;
19888  PyObject *argv[3] = {
19889  0
19890  };
19891  Py_ssize_t ii;
19892 
19893  if (!PyTuple_Check(args)) SWIG_fail;
19894  argc = args ? PyObject_Length(args) : 0;
19895  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
19896  argv[ii] = PyTuple_GET_ITEM(args,ii);
19897  }
19898  if (argc == 1) {
19899  int _v;
19900  void *vptr = 0;
19901  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
19902  _v = SWIG_CheckState(res);
19903  if (_v) {
19904  return _wrap_ios_tie__SWIG_0(self, args);
19905  }
19906  }
19907  if (argc == 2) {
19908  int _v;
19909  void *vptr = 0;
19910  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
19911  _v = SWIG_CheckState(res);
19912  if (_v) {
19913  void *vptr = 0;
19914  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
19915  _v = SWIG_CheckState(res);
19916  if (_v) {
19917  return _wrap_ios_tie__SWIG_1(self, args);
19918  }
19919  }
19920  }
19921 
19922 fail:
19923  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_tie'.\n"
19924  " Possible C/C++ prototypes are:\n"
19925  " std::basic_ios< char >::tie() const\n"
19926  " std::basic_ios< char >::tie(std::basic_ostream< char,std::char_traits< char > > *)\n");
19927  return 0;
19928 }
19929 
19930 
19931 SWIGINTERN PyObject *_wrap_ios_rdbuf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19932  PyObject *resultobj = 0;
19933  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19934  void *argp1 = 0 ;
19935  int res1 = 0 ;
19936  PyObject * obj0 = 0 ;
19937  std::basic_streambuf< char,std::char_traits< char > > *result = 0 ;
19938 
19939  if (!PyArg_ParseTuple(args,(char *)"O:ios_rdbuf",&obj0)) SWIG_fail;
19940  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19941  if (!SWIG_IsOK(res1)) {
19942  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_rdbuf" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
19943  }
19944  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19945  result = (std::basic_streambuf< char,std::char_traits< char > > *)((std::basic_ios< char > const *)arg1)->rdbuf();
19946  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
19947  return resultobj;
19948 fail:
19949  return NULL;
19950 }
19951 
19952 
19953 SWIGINTERN PyObject *_wrap_ios_rdbuf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19954  PyObject *resultobj = 0;
19955  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
19956  std::basic_streambuf< char,std::char_traits< char > > *arg2 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
19957  void *argp1 = 0 ;
19958  int res1 = 0 ;
19959  void *argp2 = 0 ;
19960  int res2 = 0 ;
19961  PyObject * obj0 = 0 ;
19962  PyObject * obj1 = 0 ;
19963  std::basic_streambuf< char,std::char_traits< char > > *result = 0 ;
19964 
19965  if (!PyArg_ParseTuple(args,(char *)"OO:ios_rdbuf",&obj0,&obj1)) SWIG_fail;
19966  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
19967  if (!SWIG_IsOK(res1)) {
19968  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_rdbuf" "', argument " "1"" of type '" "std::basic_ios< char > *""'");
19969  }
19970  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
19971  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
19972  if (!SWIG_IsOK(res2)) {
19973  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ios_rdbuf" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'");
19974  }
19975  arg2 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp2);
19976  result = (std::basic_streambuf< char,std::char_traits< char > > *)(arg1)->rdbuf(arg2);
19977  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
19978  return resultobj;
19979 fail:
19980  return NULL;
19981 }
19982 
19983 
19984 SWIGINTERN PyObject *_wrap_ios_rdbuf(PyObject *self, PyObject *args) {
19985  Py_ssize_t argc;
19986  PyObject *argv[3] = {
19987  0
19988  };
19989  Py_ssize_t ii;
19990 
19991  if (!PyTuple_Check(args)) SWIG_fail;
19992  argc = args ? PyObject_Length(args) : 0;
19993  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
19994  argv[ii] = PyTuple_GET_ITEM(args,ii);
19995  }
19996  if (argc == 1) {
19997  int _v;
19998  void *vptr = 0;
19999  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
20000  _v = SWIG_CheckState(res);
20001  if (_v) {
20002  return _wrap_ios_rdbuf__SWIG_0(self, args);
20003  }
20004  }
20005  if (argc == 2) {
20006  int _v;
20007  void *vptr = 0;
20008  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
20009  _v = SWIG_CheckState(res);
20010  if (_v) {
20011  void *vptr = 0;
20012  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
20013  _v = SWIG_CheckState(res);
20014  if (_v) {
20015  return _wrap_ios_rdbuf__SWIG_1(self, args);
20016  }
20017  }
20018  }
20019 
20020 fail:
20021  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_rdbuf'.\n"
20022  " Possible C/C++ prototypes are:\n"
20023  " std::basic_ios< char >::rdbuf() const\n"
20024  " std::basic_ios< char >::rdbuf(std::basic_streambuf< char,std::char_traits< char > > *)\n");
20025  return 0;
20026 }
20027 
20028 
20029 SWIGINTERN PyObject *_wrap_ios_copyfmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20030  PyObject *resultobj = 0;
20031  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
20032  std::basic_ios< char > *arg2 = 0 ;
20033  void *argp1 = 0 ;
20034  int res1 = 0 ;
20035  void *argp2 = 0 ;
20036  int res2 = 0 ;
20037  PyObject * obj0 = 0 ;
20038  PyObject * obj1 = 0 ;
20039  std::basic_ios< char > *result = 0 ;
20040 
20041  if (!PyArg_ParseTuple(args,(char *)"OO:ios_copyfmt",&obj0,&obj1)) SWIG_fail;
20042  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
20043  if (!SWIG_IsOK(res1)) {
20044  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_copyfmt" "', argument " "1"" of type '" "std::basic_ios< char > *""'");
20045  }
20046  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
20047  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0);
20048  if (!SWIG_IsOK(res2)) {
20049  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ios_copyfmt" "', argument " "2"" of type '" "std::basic_ios< char > const &""'");
20050  }
20051  if (!argp2) {
20052  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ios_copyfmt" "', argument " "2"" of type '" "std::basic_ios< char > const &""'");
20053  }
20054  arg2 = reinterpret_cast< std::basic_ios< char > * >(argp2);
20055  result = (std::basic_ios< char > *) &(arg1)->copyfmt((std::basic_ios< char > const &)*arg2);
20056  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
20057  return resultobj;
20058 fail:
20059  return NULL;
20060 }
20061 
20062 
20063 SWIGINTERN PyObject *_wrap_ios_fill__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20064  PyObject *resultobj = 0;
20065  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
20066  void *argp1 = 0 ;
20067  int res1 = 0 ;
20068  PyObject * obj0 = 0 ;
20069  std::basic_ios< char >::char_type result;
20070 
20071  if (!PyArg_ParseTuple(args,(char *)"O:ios_fill",&obj0)) SWIG_fail;
20072  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
20073  if (!SWIG_IsOK(res1)) {
20074  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_fill" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
20075  }
20076  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
20077  result = (std::basic_ios< char >::char_type)((std::basic_ios< char > const *)arg1)->fill();
20078  resultobj = SWIG_From_char(static_cast< char >(result));
20079  return resultobj;
20080 fail:
20081  return NULL;
20082 }
20083 
20084 
20085 SWIGINTERN PyObject *_wrap_ios_fill__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20086  PyObject *resultobj = 0;
20087  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
20088  std::basic_ios< char >::char_type arg2 ;
20089  void *argp1 = 0 ;
20090  int res1 = 0 ;
20091  char val2 ;
20092  int ecode2 = 0 ;
20093  PyObject * obj0 = 0 ;
20094  PyObject * obj1 = 0 ;
20095  std::basic_ios< char >::char_type result;
20096 
20097  if (!PyArg_ParseTuple(args,(char *)"OO:ios_fill",&obj0,&obj1)) SWIG_fail;
20098  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
20099  if (!SWIG_IsOK(res1)) {
20100  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_fill" "', argument " "1"" of type '" "std::basic_ios< char > *""'");
20101  }
20102  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
20103  ecode2 = SWIG_AsVal_char(obj1, &val2);
20104  if (!SWIG_IsOK(ecode2)) {
20105  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_fill" "', argument " "2"" of type '" "std::basic_ios< char >::char_type""'");
20106  }
20107  arg2 = static_cast< std::basic_ios< char >::char_type >(val2);
20108  result = (std::basic_ios< char >::char_type)(arg1)->fill(arg2);
20109  resultobj = SWIG_From_char(static_cast< char >(result));
20110  return resultobj;
20111 fail:
20112  return NULL;
20113 }
20114 
20115 
20116 SWIGINTERN PyObject *_wrap_ios_fill(PyObject *self, PyObject *args) {
20117  Py_ssize_t argc;
20118  PyObject *argv[3] = {
20119  0
20120  };
20121  Py_ssize_t ii;
20122 
20123  if (!PyTuple_Check(args)) SWIG_fail;
20124  argc = args ? PyObject_Length(args) : 0;
20125  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
20126  argv[ii] = PyTuple_GET_ITEM(args,ii);
20127  }
20128  if (argc == 1) {
20129  int _v;
20130  void *vptr = 0;
20131  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
20132  _v = SWIG_CheckState(res);
20133  if (_v) {
20134  return _wrap_ios_fill__SWIG_0(self, args);
20135  }
20136  }
20137  if (argc == 2) {
20138  int _v;
20139  void *vptr = 0;
20140  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
20141  _v = SWIG_CheckState(res);
20142  if (_v) {
20143  {
20144  int res = SWIG_AsVal_char(argv[1], NULL);
20145  _v = SWIG_CheckState(res);
20146  }
20147  if (_v) {
20148  return _wrap_ios_fill__SWIG_1(self, args);
20149  }
20150  }
20151  }
20152 
20153 fail:
20154  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_fill'.\n"
20155  " Possible C/C++ prototypes are:\n"
20156  " std::basic_ios< char >::fill() const\n"
20157  " std::basic_ios< char >::fill(std::basic_ios< char >::char_type)\n");
20158  return 0;
20159 }
20160 
20161 
20162 SWIGINTERN PyObject *_wrap_ios_imbue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20163  PyObject *resultobj = 0;
20164  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
20165  std::locale *arg2 = 0 ;
20166  void *argp1 = 0 ;
20167  int res1 = 0 ;
20168  void *argp2 = 0 ;
20169  int res2 = 0 ;
20170  PyObject * obj0 = 0 ;
20171  PyObject * obj1 = 0 ;
20172  std::locale result;
20173 
20174  if (!PyArg_ParseTuple(args,(char *)"OO:ios_imbue",&obj0,&obj1)) SWIG_fail;
20175  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
20176  if (!SWIG_IsOK(res1)) {
20177  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_imbue" "', argument " "1"" of type '" "std::basic_ios< char > *""'");
20178  }
20179  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
20180  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__locale, 0 | 0);
20181  if (!SWIG_IsOK(res2)) {
20182  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ios_imbue" "', argument " "2"" of type '" "std::locale const &""'");
20183  }
20184  if (!argp2) {
20185  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ios_imbue" "', argument " "2"" of type '" "std::locale const &""'");
20186  }
20187  arg2 = reinterpret_cast< std::locale * >(argp2);
20188  result = (arg1)->imbue((std::locale const &)*arg2);
20189  resultobj = SWIG_NewPointerObj((new std::locale(static_cast< const std::locale& >(result))), SWIGTYPE_p_std__locale, SWIG_POINTER_OWN | 0 );
20190  return resultobj;
20191 fail:
20192  return NULL;
20193 }
20194 
20195 
20196 SWIGINTERN PyObject *_wrap_ios_narrow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20197  PyObject *resultobj = 0;
20198  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
20199  std::basic_ios< char >::char_type arg2 ;
20200  char arg3 ;
20201  void *argp1 = 0 ;
20202  int res1 = 0 ;
20203  char val2 ;
20204  int ecode2 = 0 ;
20205  char val3 ;
20206  int ecode3 = 0 ;
20207  PyObject * obj0 = 0 ;
20208  PyObject * obj1 = 0 ;
20209  PyObject * obj2 = 0 ;
20210  char result;
20211 
20212  if (!PyArg_ParseTuple(args,(char *)"OOO:ios_narrow",&obj0,&obj1,&obj2)) SWIG_fail;
20213  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
20214  if (!SWIG_IsOK(res1)) {
20215  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_narrow" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
20216  }
20217  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
20218  ecode2 = SWIG_AsVal_char(obj1, &val2);
20219  if (!SWIG_IsOK(ecode2)) {
20220  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_narrow" "', argument " "2"" of type '" "std::basic_ios< char >::char_type""'");
20221  }
20222  arg2 = static_cast< std::basic_ios< char >::char_type >(val2);
20223  ecode3 = SWIG_AsVal_char(obj2, &val3);
20224  if (!SWIG_IsOK(ecode3)) {
20225  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ios_narrow" "', argument " "3"" of type '" "char""'");
20226  }
20227  arg3 = static_cast< char >(val3);
20228  result = (char)((std::basic_ios< char > const *)arg1)->narrow(arg2,arg3);
20229  resultobj = SWIG_From_char(static_cast< char >(result));
20230  return resultobj;
20231 fail:
20232  return NULL;
20233 }
20234 
20235 
20236 SWIGINTERN PyObject *_wrap_ios_widen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20237  PyObject *resultobj = 0;
20238  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
20239  char arg2 ;
20240  void *argp1 = 0 ;
20241  int res1 = 0 ;
20242  char val2 ;
20243  int ecode2 = 0 ;
20244  PyObject * obj0 = 0 ;
20245  PyObject * obj1 = 0 ;
20246  std::basic_ios< char >::char_type result;
20247 
20248  if (!PyArg_ParseTuple(args,(char *)"OO:ios_widen",&obj0,&obj1)) SWIG_fail;
20249  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 | 0 );
20250  if (!SWIG_IsOK(res1)) {
20251  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_widen" "', argument " "1"" of type '" "std::basic_ios< char > const *""'");
20252  }
20253  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
20254  ecode2 = SWIG_AsVal_char(obj1, &val2);
20255  if (!SWIG_IsOK(ecode2)) {
20256  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_widen" "', argument " "2"" of type '" "char""'");
20257  }
20258  arg2 = static_cast< char >(val2);
20259  result = (std::basic_ios< char >::char_type)((std::basic_ios< char > const *)arg1)->widen(arg2);
20260  resultobj = SWIG_From_char(static_cast< char >(result));
20261  return resultobj;
20262 fail:
20263  return NULL;
20264 }
20265 
20266 
20267 SWIGINTERN PyObject *ios_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20268  PyObject *obj;
20269  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20270  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
20271  return SWIG_Py_Void();
20272 }
20273 
20274 SWIGINTERN int Swig_var_cin_set(PyObject *) {
20275  SWIG_Error(SWIG_AttributeError,"Variable cin is read-only.");
20276  return 1;
20277 }
20278 
20279 
20280 SWIGINTERN PyObject *Swig_var_cin_get(void) {
20281  PyObject *pyobj = 0;
20282 
20283  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::cin), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
20284  return pyobj;
20285 }
20286 
20287 
20288 SWIGINTERN int Swig_var_cout_set(PyObject *) {
20289  SWIG_Error(SWIG_AttributeError,"Variable cout is read-only.");
20290  return 1;
20291 }
20292 
20293 
20294 SWIGINTERN PyObject *Swig_var_cout_get(void) {
20295  PyObject *pyobj = 0;
20296 
20297  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::cout), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
20298  return pyobj;
20299 }
20300 
20301 
20302 SWIGINTERN int Swig_var_cerr_set(PyObject *) {
20303  SWIG_Error(SWIG_AttributeError,"Variable cerr is read-only.");
20304  return 1;
20305 }
20306 
20307 
20308 SWIGINTERN PyObject *Swig_var_cerr_get(void) {
20309  PyObject *pyobj = 0;
20310 
20311  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::cerr), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
20312  return pyobj;
20313 }
20314 
20315 
20316 SWIGINTERN int Swig_var_clog_set(PyObject *) {
20317  SWIG_Error(SWIG_AttributeError,"Variable clog is read-only.");
20318  return 1;
20319 }
20320 
20321 
20322 SWIGINTERN PyObject *Swig_var_clog_get(void) {
20323  PyObject *pyobj = 0;
20324 
20325  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::clog), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
20326  return pyobj;
20327 }
20328 
20329 
20330 SWIGINTERN PyObject *_wrap_new_ostream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20331  PyObject *resultobj = 0;
20332  std::basic_streambuf< char,std::char_traits< char > > *arg1 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
20333  void *argp1 = 0 ;
20334  int res1 = 0 ;
20335  PyObject * obj0 = 0 ;
20336  std::basic_ostream< char > *result = 0 ;
20337 
20338  if (!PyArg_ParseTuple(args,(char *)"O:new_ostream",&obj0)) SWIG_fail;
20339  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
20340  if (!SWIG_IsOK(res1)) {
20341  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ostream" "', argument " "1"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'");
20342  }
20343  arg1 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp1);
20344  result = (std::basic_ostream< char > *)new std::basic_ostream< char >(arg1);
20345  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NEW | 0 );
20346  return resultobj;
20347 fail:
20348  return NULL;
20349 }
20350 
20351 
20352 SWIGINTERN PyObject *_wrap_delete_ostream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20353  PyObject *resultobj = 0;
20354  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20355  void *argp1 = 0 ;
20356  int res1 = 0 ;
20357  PyObject * obj0 = 0 ;
20358 
20359  if (!PyArg_ParseTuple(args,(char *)"O:delete_ostream",&obj0)) SWIG_fail;
20360  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN | 0 );
20361  if (!SWIG_IsOK(res1)) {
20362  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ostream" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20363  }
20364  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20365  delete arg1;
20366  resultobj = SWIG_Py_Void();
20367  return resultobj;
20368 fail:
20369  return NULL;
20370 }
20371 
20372 
20373 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20374  PyObject *resultobj = 0;
20375  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20376  std::basic_ostream< char,std::char_traits< char > > &(*arg2)(std::basic_ostream< char,std::char_traits< char > > &) = (std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &)) 0 ;
20377  void *argp1 = 0 ;
20378  int res1 = 0 ;
20379  PyObject * obj0 = 0 ;
20380  PyObject * obj1 = 0 ;
20381  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20382 
20383  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20384  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20385  if (!SWIG_IsOK(res1)) {
20386  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20387  }
20388  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20389  {
20390  int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
20391  if (!SWIG_IsOK(res)) {
20392  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &)""'");
20393  }
20394  }
20395  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20396  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20397  return resultobj;
20398 fail:
20399  return NULL;
20400 }
20401 
20402 
20403 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20404  PyObject *resultobj = 0;
20405  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20406  std::basic_ios< char,std::char_traits< char > > &(*arg2)(std::basic_ios< char,std::char_traits< char > > &) = (std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) 0 ;
20407  void *argp1 = 0 ;
20408  int res1 = 0 ;
20409  PyObject * obj0 = 0 ;
20410  PyObject * obj1 = 0 ;
20411  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20412 
20413  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20414  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20415  if (!SWIG_IsOK(res1)) {
20416  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20417  }
20418  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20419  {
20420  int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t);
20421  if (!SWIG_IsOK(res)) {
20422  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)""'");
20423  }
20424  }
20425  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20426  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20427  return resultobj;
20428 fail:
20429  return NULL;
20430 }
20431 
20432 
20433 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20434  PyObject *resultobj = 0;
20435  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20436  std::ios_base &(*arg2)(std::ios_base &) = (std::ios_base &(*)(std::ios_base &)) 0 ;
20437  void *argp1 = 0 ;
20438  int res1 = 0 ;
20439  PyObject * obj0 = 0 ;
20440  PyObject * obj1 = 0 ;
20441  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20442 
20443  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20444  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20445  if (!SWIG_IsOK(res1)) {
20446  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20447  }
20448  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20449  {
20450  int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base);
20451  if (!SWIG_IsOK(res)) {
20452  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::ios_base &(*)(std::ios_base &)""'");
20453  }
20454  }
20455  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20456  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20457  return resultobj;
20458 fail:
20459  return NULL;
20460 }
20461 
20462 
20463 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20464  PyObject *resultobj = 0;
20465  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20466  long arg2 ;
20467  void *argp1 = 0 ;
20468  int res1 = 0 ;
20469  long val2 ;
20470  int ecode2 = 0 ;
20471  PyObject * obj0 = 0 ;
20472  PyObject * obj1 = 0 ;
20473  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20474 
20475  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20476  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20477  if (!SWIG_IsOK(res1)) {
20478  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20479  }
20480  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20481  ecode2 = SWIG_AsVal_long(obj1, &val2);
20482  if (!SWIG_IsOK(ecode2)) {
20483  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "long""'");
20484  }
20485  arg2 = static_cast< long >(val2);
20486  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20487  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20488  return resultobj;
20489 fail:
20490  return NULL;
20491 }
20492 
20493 
20494 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20495  PyObject *resultobj = 0;
20496  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20497  unsigned long arg2 ;
20498  void *argp1 = 0 ;
20499  int res1 = 0 ;
20500  unsigned long val2 ;
20501  int ecode2 = 0 ;
20502  PyObject * obj0 = 0 ;
20503  PyObject * obj1 = 0 ;
20504  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20505 
20506  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20507  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20508  if (!SWIG_IsOK(res1)) {
20509  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20510  }
20511  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20512  ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
20513  if (!SWIG_IsOK(ecode2)) {
20514  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "unsigned long""'");
20515  }
20516  arg2 = static_cast< unsigned long >(val2);
20517  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20518  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20519  return resultobj;
20520 fail:
20521  return NULL;
20522 }
20523 
20524 
20525 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20526  PyObject *resultobj = 0;
20527  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20528  bool arg2 ;
20529  void *argp1 = 0 ;
20530  int res1 = 0 ;
20531  bool val2 ;
20532  int ecode2 = 0 ;
20533  PyObject * obj0 = 0 ;
20534  PyObject * obj1 = 0 ;
20535  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20536 
20537  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20538  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20539  if (!SWIG_IsOK(res1)) {
20540  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20541  }
20542  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20543  ecode2 = SWIG_AsVal_bool(obj1, &val2);
20544  if (!SWIG_IsOK(ecode2)) {
20545  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "bool""'");
20546  }
20547  arg2 = static_cast< bool >(val2);
20548  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20549  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20550  return resultobj;
20551 fail:
20552  return NULL;
20553 }
20554 
20555 
20556 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20557  PyObject *resultobj = 0;
20558  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20559  short arg2 ;
20560  void *argp1 = 0 ;
20561  int res1 = 0 ;
20562  short val2 ;
20563  int ecode2 = 0 ;
20564  PyObject * obj0 = 0 ;
20565  PyObject * obj1 = 0 ;
20566  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20567 
20568  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20569  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20570  if (!SWIG_IsOK(res1)) {
20571  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20572  }
20573  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20574  ecode2 = SWIG_AsVal_short(obj1, &val2);
20575  if (!SWIG_IsOK(ecode2)) {
20576  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "short""'");
20577  }
20578  arg2 = static_cast< short >(val2);
20579  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20580  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20581  return resultobj;
20582 fail:
20583  return NULL;
20584 }
20585 
20586 
20587 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20588  PyObject *resultobj = 0;
20589  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20590  unsigned short arg2 ;
20591  void *argp1 = 0 ;
20592  int res1 = 0 ;
20593  unsigned short val2 ;
20594  int ecode2 = 0 ;
20595  PyObject * obj0 = 0 ;
20596  PyObject * obj1 = 0 ;
20597  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20598 
20599  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20600  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20601  if (!SWIG_IsOK(res1)) {
20602  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20603  }
20604  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20605  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
20606  if (!SWIG_IsOK(ecode2)) {
20607  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "unsigned short""'");
20608  }
20609  arg2 = static_cast< unsigned short >(val2);
20610  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20611  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20612  return resultobj;
20613 fail:
20614  return NULL;
20615 }
20616 
20617 
20618 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20619  PyObject *resultobj = 0;
20620  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20621  int arg2 ;
20622  void *argp1 = 0 ;
20623  int res1 = 0 ;
20624  int val2 ;
20625  int ecode2 = 0 ;
20626  PyObject * obj0 = 0 ;
20627  PyObject * obj1 = 0 ;
20628  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20629 
20630  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20631  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20632  if (!SWIG_IsOK(res1)) {
20633  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20634  }
20635  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20636  ecode2 = SWIG_AsVal_int(obj1, &val2);
20637  if (!SWIG_IsOK(ecode2)) {
20638  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "int""'");
20639  }
20640  arg2 = static_cast< int >(val2);
20641  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20642  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20643  return resultobj;
20644 fail:
20645  return NULL;
20646 }
20647 
20648 
20649 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20650  PyObject *resultobj = 0;
20651  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20652  unsigned int arg2 ;
20653  void *argp1 = 0 ;
20654  int res1 = 0 ;
20655  unsigned int val2 ;
20656  int ecode2 = 0 ;
20657  PyObject * obj0 = 0 ;
20658  PyObject * obj1 = 0 ;
20659  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20660 
20661  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20662  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20663  if (!SWIG_IsOK(res1)) {
20664  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20665  }
20666  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20667  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
20668  if (!SWIG_IsOK(ecode2)) {
20669  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "unsigned int""'");
20670  }
20671  arg2 = static_cast< unsigned int >(val2);
20672  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20673  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20674  return resultobj;
20675 fail:
20676  return NULL;
20677 }
20678 
20679 
20680 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20681  PyObject *resultobj = 0;
20682  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20683  long long arg2 ;
20684  void *argp1 = 0 ;
20685  int res1 = 0 ;
20686  long long val2 ;
20687  int ecode2 = 0 ;
20688  PyObject * obj0 = 0 ;
20689  PyObject * obj1 = 0 ;
20690  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20691 
20692  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20693  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20694  if (!SWIG_IsOK(res1)) {
20695  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20696  }
20697  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20698  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
20699  if (!SWIG_IsOK(ecode2)) {
20700  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "long long""'");
20701  }
20702  arg2 = static_cast< long long >(val2);
20703  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20704  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20705  return resultobj;
20706 fail:
20707  return NULL;
20708 }
20709 
20710 
20711 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20712  PyObject *resultobj = 0;
20713  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20714  unsigned long long arg2 ;
20715  void *argp1 = 0 ;
20716  int res1 = 0 ;
20717  unsigned long long val2 ;
20718  int ecode2 = 0 ;
20719  PyObject * obj0 = 0 ;
20720  PyObject * obj1 = 0 ;
20721  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20722 
20723  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20724  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20725  if (!SWIG_IsOK(res1)) {
20726  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20727  }
20728  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20729  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
20730  if (!SWIG_IsOK(ecode2)) {
20731  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "unsigned long long""'");
20732  }
20733  arg2 = static_cast< unsigned long long >(val2);
20734  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20735  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20736  return resultobj;
20737 fail:
20738  return NULL;
20739 }
20740 
20741 
20742 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20743  PyObject *resultobj = 0;
20744  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20745  double arg2 ;
20746  void *argp1 = 0 ;
20747  int res1 = 0 ;
20748  double val2 ;
20749  int ecode2 = 0 ;
20750  PyObject * obj0 = 0 ;
20751  PyObject * obj1 = 0 ;
20752  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20753 
20754  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20755  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20756  if (!SWIG_IsOK(res1)) {
20757  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20758  }
20759  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20760  ecode2 = SWIG_AsVal_double(obj1, &val2);
20761  if (!SWIG_IsOK(ecode2)) {
20762  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "double""'");
20763  }
20764  arg2 = static_cast< double >(val2);
20765  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20766  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20767  return resultobj;
20768 fail:
20769  return NULL;
20770 }
20771 
20772 
20773 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20774  PyObject *resultobj = 0;
20775  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20776  float arg2 ;
20777  void *argp1 = 0 ;
20778  int res1 = 0 ;
20779  float val2 ;
20780  int ecode2 = 0 ;
20781  PyObject * obj0 = 0 ;
20782  PyObject * obj1 = 0 ;
20783  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20784 
20785  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20786  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20787  if (!SWIG_IsOK(res1)) {
20788  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20789  }
20790  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20791  ecode2 = SWIG_AsVal_float(obj1, &val2);
20792  if (!SWIG_IsOK(ecode2)) {
20793  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "float""'");
20794  }
20795  arg2 = static_cast< float >(val2);
20796  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20797  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20798  return resultobj;
20799 fail:
20800  return NULL;
20801 }
20802 
20803 
20804 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20805  PyObject *resultobj = 0;
20806  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20807  long double arg2 ;
20808  void *argp1 = 0 ;
20809  int res1 = 0 ;
20810  void *argp2 ;
20811  int res2 = 0 ;
20812  PyObject * obj0 = 0 ;
20813  PyObject * obj1 = 0 ;
20814  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20815 
20816  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20817  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20818  if (!SWIG_IsOK(res1)) {
20819  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20820  }
20821  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20822  {
20823  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long_double, 0 | 0);
20824  if (!SWIG_IsOK(res2)) {
20825  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "long double""'");
20826  }
20827  if (!argp2) {
20828  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ostream___lshift__" "', argument " "2"" of type '" "long double""'");
20829  } else {
20830  long double * temp = reinterpret_cast< long double * >(argp2);
20831  arg2 = *temp;
20832  if (SWIG_IsNewObj(res2)) delete temp;
20833  }
20834  }
20835  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20836  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20837  return resultobj;
20838 fail:
20839  return NULL;
20840 }
20841 
20842 
20843 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20844  PyObject *resultobj = 0;
20845  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20846  void *arg2 = (void *) 0 ;
20847  void *argp1 = 0 ;
20848  int res1 = 0 ;
20849  int res2 ;
20850  PyObject * obj0 = 0 ;
20851  PyObject * obj1 = 0 ;
20852  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20853 
20854  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20855  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20856  if (!SWIG_IsOK(res1)) {
20857  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20858  }
20859  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20860  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
20861  if (!SWIG_IsOK(res2)) {
20862  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "void const *""'");
20863  }
20864  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<((void const *)arg2);
20865  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20866  return resultobj;
20867 fail:
20868  return NULL;
20869 }
20870 
20871 
20872 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20873  PyObject *resultobj = 0;
20874  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20875  std::basic_streambuf< char,std::char_traits< char > > *arg2 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
20876  void *argp1 = 0 ;
20877  int res1 = 0 ;
20878  void *argp2 = 0 ;
20879  int res2 = 0 ;
20880  PyObject * obj0 = 0 ;
20881  PyObject * obj1 = 0 ;
20882  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20883 
20884  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20885  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20886  if (!SWIG_IsOK(res1)) {
20887  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20888  }
20889  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20890  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
20891  if (!SWIG_IsOK(res2)) {
20892  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'");
20893  }
20894  arg2 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp2);
20895  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
20896  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20897  return resultobj;
20898 fail:
20899  return NULL;
20900 }
20901 
20902 
20903 SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20904  PyObject *resultobj = 0;
20905  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
20906  std::basic_string< char,std::char_traits< char >,std::allocator< char > > *arg2 = 0 ;
20907  void *argp1 = 0 ;
20908  int res1 = 0 ;
20909  void *argp2 = 0 ;
20910  int res2 = 0 ;
20911  PyObject * obj0 = 0 ;
20912  PyObject * obj1 = 0 ;
20913  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
20914 
20915  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
20916  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20917  if (!SWIG_IsOK(res1)) {
20918  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
20919  }
20920  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
20921  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0);
20922  if (!SWIG_IsOK(res2)) {
20923  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
20924  }
20925  if (!argp2) {
20926  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
20927  }
20928  arg2 = reinterpret_cast< std::basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp2);
20929  result = (std::basic_ostream< char,std::char_traits< char > > *) &std_basic_ostream_Sl_char_Sg__operator_Sl__Sl___SWIG_17(arg1,(std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg2);
20930  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
20931  return resultobj;
20932 fail:
20933  return NULL;
20934 }
20935 
20936 
20937 SWIGINTERN PyObject *_wrap_ostream___lshift__(PyObject *self, PyObject *args) {
20938  Py_ssize_t argc;
20939  PyObject *argv[3] = {
20940  0
20941  };
20942  Py_ssize_t ii;
20943 
20944  if (!PyTuple_Check(args)) SWIG_fail;
20945  argc = args ? PyObject_Length(args) : 0;
20946  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
20947  argv[ii] = PyTuple_GET_ITEM(args,ii);
20948  }
20949  if (argc == 2) {
20950  int _v;
20951  void *vptr = 0;
20952  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
20953  _v = SWIG_CheckState(res);
20954  if (_v) {
20955  void *ptr = 0;
20956  int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
20957  _v = SWIG_CheckState(res);
20958  if (_v) {
20959  return _wrap_ostream___lshift____SWIG_0(self, args);
20960  }
20961  }
20962  }
20963  if (argc == 2) {
20964  int _v;
20965  void *vptr = 0;
20966  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
20967  _v = SWIG_CheckState(res);
20968  if (_v) {
20969  void *ptr = 0;
20970  int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t);
20971  _v = SWIG_CheckState(res);
20972  if (_v) {
20973  return _wrap_ostream___lshift____SWIG_1(self, args);
20974  }
20975  }
20976  }
20977  if (argc == 2) {
20978  int _v;
20979  void *vptr = 0;
20980  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
20981  _v = SWIG_CheckState(res);
20982  if (_v) {
20983  void *ptr = 0;
20984  int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base);
20985  _v = SWIG_CheckState(res);
20986  if (_v) {
20987  return _wrap_ostream___lshift____SWIG_2(self, args);
20988  }
20989  }
20990  }
20991  if (argc == 2) {
20992  int _v;
20993  void *vptr = 0;
20994  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
20995  _v = SWIG_CheckState(res);
20996  if (_v) {
20997  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_long_double, 0);
20998  _v = SWIG_CheckState(res);
20999  if (_v) {
21000  return _wrap_ostream___lshift____SWIG_14(self, args);
21001  }
21002  }
21003  }
21004  if (argc == 2) {
21005  int _v;
21006  void *vptr = 0;
21007  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21008  _v = SWIG_CheckState(res);
21009  if (_v) {
21010  void *vptr = 0;
21011  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
21012  _v = SWIG_CheckState(res);
21013  if (_v) {
21014  return _wrap_ostream___lshift____SWIG_16(self, args);
21015  }
21016  }
21017  }
21018  if (argc == 2) {
21019  int _v;
21020  void *vptr = 0;
21021  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21022  _v = SWIG_CheckState(res);
21023  if (_v) {
21024  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
21025  _v = SWIG_CheckState(res);
21026  if (_v) {
21027  return _wrap_ostream___lshift____SWIG_17(self, args);
21028  }
21029  }
21030  }
21031  if (argc == 2) {
21032  int _v;
21033  void *vptr = 0;
21034  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21035  _v = SWIG_CheckState(res);
21036  if (_v) {
21037  void *ptr = 0;
21038  int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
21039  _v = SWIG_CheckState(res);
21040  if (_v) {
21041  return _wrap_ostream___lshift____SWIG_15(self, args);
21042  }
21043  }
21044  }
21045  if (argc == 2) {
21046  int _v;
21047  void *vptr = 0;
21048  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21049  _v = SWIG_CheckState(res);
21050  if (_v) {
21051  {
21052  int res = SWIG_AsVal_bool(argv[1], NULL);
21053  _v = SWIG_CheckState(res);
21054  }
21055  if (_v) {
21056  return _wrap_ostream___lshift____SWIG_5(self, args);
21057  }
21058  }
21059  }
21060  if (argc == 2) {
21061  int _v;
21062  void *vptr = 0;
21063  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21064  _v = SWIG_CheckState(res);
21065  if (_v) {
21066  {
21067  int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
21068  _v = SWIG_CheckState(res);
21069  }
21070  if (_v) {
21071  return _wrap_ostream___lshift____SWIG_7(self, args);
21072  }
21073  }
21074  }
21075  if (argc == 2) {
21076  int _v;
21077  void *vptr = 0;
21078  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21079  _v = SWIG_CheckState(res);
21080  if (_v) {
21081  {
21082  int res = SWIG_AsVal_short(argv[1], NULL);
21083  _v = SWIG_CheckState(res);
21084  }
21085  if (_v) {
21086  return _wrap_ostream___lshift____SWIG_6(self, args);
21087  }
21088  }
21089  }
21090  if (argc == 2) {
21091  int _v;
21092  void *vptr = 0;
21093  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21094  _v = SWIG_CheckState(res);
21095  if (_v) {
21096  {
21097  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
21098  _v = SWIG_CheckState(res);
21099  }
21100  if (_v) {
21101  return _wrap_ostream___lshift____SWIG_9(self, args);
21102  }
21103  }
21104  }
21105  if (argc == 2) {
21106  int _v;
21107  void *vptr = 0;
21108  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21109  _v = SWIG_CheckState(res);
21110  if (_v) {
21111  {
21112  int res = SWIG_AsVal_int(argv[1], NULL);
21113  _v = SWIG_CheckState(res);
21114  }
21115  if (_v) {
21116  return _wrap_ostream___lshift____SWIG_8(self, args);
21117  }
21118  }
21119  }
21120  if (argc == 2) {
21121  int _v;
21122  void *vptr = 0;
21123  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21124  _v = SWIG_CheckState(res);
21125  if (_v) {
21126  {
21127  int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
21128  _v = SWIG_CheckState(res);
21129  }
21130  if (_v) {
21131  return _wrap_ostream___lshift____SWIG_4(self, args);
21132  }
21133  }
21134  }
21135  if (argc == 2) {
21136  int _v;
21137  void *vptr = 0;
21138  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21139  _v = SWIG_CheckState(res);
21140  if (_v) {
21141  {
21142  int res = SWIG_AsVal_long(argv[1], NULL);
21143  _v = SWIG_CheckState(res);
21144  }
21145  if (_v) {
21146  return _wrap_ostream___lshift____SWIG_3(self, args);
21147  }
21148  }
21149  }
21150  if (argc == 2) {
21151  int _v;
21152  void *vptr = 0;
21153  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21154  _v = SWIG_CheckState(res);
21155  if (_v) {
21156  {
21157  int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
21158  _v = SWIG_CheckState(res);
21159  }
21160  if (_v) {
21161  return _wrap_ostream___lshift____SWIG_11(self, args);
21162  }
21163  }
21164  }
21165  if (argc == 2) {
21166  int _v;
21167  void *vptr = 0;
21168  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21169  _v = SWIG_CheckState(res);
21170  if (_v) {
21171  {
21172  int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
21173  _v = SWIG_CheckState(res);
21174  }
21175  if (_v) {
21176  return _wrap_ostream___lshift____SWIG_10(self, args);
21177  }
21178  }
21179  }
21180  if (argc == 2) {
21181  int _v;
21182  void *vptr = 0;
21183  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21184  _v = SWIG_CheckState(res);
21185  if (_v) {
21186  {
21187  int res = SWIG_AsVal_float(argv[1], NULL);
21188  _v = SWIG_CheckState(res);
21189  }
21190  if (_v) {
21191  return _wrap_ostream___lshift____SWIG_13(self, args);
21192  }
21193  }
21194  }
21195  if (argc == 2) {
21196  int _v;
21197  void *vptr = 0;
21198  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21199  _v = SWIG_CheckState(res);
21200  if (_v) {
21201  {
21202  int res = SWIG_AsVal_double(argv[1], NULL);
21203  _v = SWIG_CheckState(res);
21204  }
21205  if (_v) {
21206  return _wrap_ostream___lshift____SWIG_12(self, args);
21207  }
21208  }
21209  }
21210 
21211 fail:
21212  Py_INCREF(Py_NotImplemented);
21213  return Py_NotImplemented;
21214 }
21215 
21216 
21217 SWIGINTERN PyObject *_wrap_ostream_put(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21218  PyObject *resultobj = 0;
21219  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
21220  std::basic_ostream< char >::char_type arg2 ;
21221  void *argp1 = 0 ;
21222  int res1 = 0 ;
21223  char val2 ;
21224  int ecode2 = 0 ;
21225  PyObject * obj0 = 0 ;
21226  PyObject * obj1 = 0 ;
21227  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
21228 
21229  if (!PyArg_ParseTuple(args,(char *)"OO:ostream_put",&obj0,&obj1)) SWIG_fail;
21230  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21231  if (!SWIG_IsOK(res1)) {
21232  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_put" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
21233  }
21234  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
21235  ecode2 = SWIG_AsVal_char(obj1, &val2);
21236  if (!SWIG_IsOK(ecode2)) {
21237  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream_put" "', argument " "2"" of type '" "std::basic_ostream< char >::char_type""'");
21238  }
21239  arg2 = static_cast< std::basic_ostream< char >::char_type >(val2);
21240  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->put(arg2);
21241  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21242  return resultobj;
21243 fail:
21244  return NULL;
21245 }
21246 
21247 
21248 SWIGINTERN PyObject *_wrap_ostream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21249  PyObject *resultobj = 0;
21250  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
21251  std::basic_ostream< char >::char_type *arg2 = (std::basic_ostream< char >::char_type *) 0 ;
21252  std::streamsize arg3 ;
21253  void *argp1 = 0 ;
21254  int res1 = 0 ;
21255  int res2 ;
21256  char *buf2 = 0 ;
21257  int alloc2 = 0 ;
21258  size_t val3 ;
21259  int ecode3 = 0 ;
21260  PyObject * obj0 = 0 ;
21261  PyObject * obj1 = 0 ;
21262  PyObject * obj2 = 0 ;
21263  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
21264 
21265  if (!PyArg_ParseTuple(args,(char *)"OOO:ostream_write",&obj0,&obj1,&obj2)) SWIG_fail;
21266  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21267  if (!SWIG_IsOK(res1)) {
21268  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_write" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
21269  }
21270  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
21271  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21272  if (!SWIG_IsOK(res2)) {
21273  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream_write" "', argument " "2"" of type '" "std::basic_ostream< char >::char_type const *""'");
21274  }
21275  arg2 = reinterpret_cast< std::basic_ostream< char >::char_type * >(buf2);
21276  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
21277  if (!SWIG_IsOK(ecode3)) {
21278  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ostream_write" "', argument " "3"" of type '" "std::streamsize""'");
21279  }
21280  arg3 = static_cast< std::streamsize >(val3);
21281  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->write((std::basic_ostream< char >::char_type const *)arg2,arg3);
21282  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21283  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21284  return resultobj;
21285 fail:
21286  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21287  return NULL;
21288 }
21289 
21290 
21291 SWIGINTERN PyObject *_wrap_ostream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21292  PyObject *resultobj = 0;
21293  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
21294  void *argp1 = 0 ;
21295  int res1 = 0 ;
21296  PyObject * obj0 = 0 ;
21297  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
21298 
21299  if (!PyArg_ParseTuple(args,(char *)"O:ostream_flush",&obj0)) SWIG_fail;
21300  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21301  if (!SWIG_IsOK(res1)) {
21302  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_flush" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
21303  }
21304  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
21305  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->flush();
21306  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21307  return resultobj;
21308 fail:
21309  return NULL;
21310 }
21311 
21312 
21313 SWIGINTERN PyObject *_wrap_ostream_tellp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21314  PyObject *resultobj = 0;
21315  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
21316  void *argp1 = 0 ;
21317  int res1 = 0 ;
21318  PyObject * obj0 = 0 ;
21319  std::basic_ostream< char >::pos_type result;
21320 
21321  if (!PyArg_ParseTuple(args,(char *)"O:ostream_tellp",&obj0)) SWIG_fail;
21322  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21323  if (!SWIG_IsOK(res1)) {
21324  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_tellp" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
21325  }
21326  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
21327  result = (arg1)->tellp();
21328  resultobj = SWIG_NewPointerObj((new std::basic_ostream< char >::pos_type(static_cast< const std::basic_ostream< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN | 0 );
21329  return resultobj;
21330 fail:
21331  return NULL;
21332 }
21333 
21334 
21335 SWIGINTERN PyObject *_wrap_ostream_seekp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21336  PyObject *resultobj = 0;
21337  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
21338  std::basic_ostream< char >::pos_type arg2 ;
21339  void *argp1 = 0 ;
21340  int res1 = 0 ;
21341  void *argp2 ;
21342  int res2 = 0 ;
21343  PyObject * obj0 = 0 ;
21344  PyObject * obj1 = 0 ;
21345  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
21346 
21347  if (!PyArg_ParseTuple(args,(char *)"OO:ostream_seekp",&obj0,&obj1)) SWIG_fail;
21348  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21349  if (!SWIG_IsOK(res1)) {
21350  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_seekp" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
21351  }
21352  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
21353  {
21354  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streampos, 0 | 0);
21355  if (!SWIG_IsOK(res2)) {
21356  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream_seekp" "', argument " "2"" of type '" "std::basic_ostream< char >::pos_type""'");
21357  }
21358  if (!argp2) {
21359  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ostream_seekp" "', argument " "2"" of type '" "std::basic_ostream< char >::pos_type""'");
21360  } else {
21361  std::basic_ostream< char >::pos_type * temp = reinterpret_cast< std::basic_ostream< char >::pos_type * >(argp2);
21362  arg2 = *temp;
21363  if (SWIG_IsNewObj(res2)) delete temp;
21364  }
21365  }
21366  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->seekp(arg2);
21367  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21368  return resultobj;
21369 fail:
21370  return NULL;
21371 }
21372 
21373 
21374 SWIGINTERN PyObject *_wrap_ostream_seekp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21375  PyObject *resultobj = 0;
21376  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
21377  std::basic_ostream< char >::off_type arg2 ;
21378  std::ios_base::seekdir arg3 ;
21379  void *argp1 = 0 ;
21380  int res1 = 0 ;
21381  void *argp2 ;
21382  int res2 = 0 ;
21383  int val3 ;
21384  int ecode3 = 0 ;
21385  PyObject * obj0 = 0 ;
21386  PyObject * obj1 = 0 ;
21387  PyObject * obj2 = 0 ;
21388  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
21389 
21390  if (!PyArg_ParseTuple(args,(char *)"OOO:ostream_seekp",&obj0,&obj1,&obj2)) SWIG_fail;
21391  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21392  if (!SWIG_IsOK(res1)) {
21393  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_seekp" "', argument " "1"" of type '" "std::basic_ostream< char > *""'");
21394  }
21395  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
21396  {
21397  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streamoff, 0 | 0);
21398  if (!SWIG_IsOK(res2)) {
21399  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream_seekp" "', argument " "2"" of type '" "std::basic_ostream< char >::off_type""'");
21400  }
21401  if (!argp2) {
21402  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ostream_seekp" "', argument " "2"" of type '" "std::basic_ostream< char >::off_type""'");
21403  } else {
21404  std::basic_ostream< char >::off_type * temp = reinterpret_cast< std::basic_ostream< char >::off_type * >(argp2);
21405  arg2 = *temp;
21406  if (SWIG_IsNewObj(res2)) delete temp;
21407  }
21408  }
21409  ecode3 = SWIG_AsVal_int(obj2, &val3);
21410  if (!SWIG_IsOK(ecode3)) {
21411  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ostream_seekp" "', argument " "3"" of type '" "std::ios_base::seekdir""'");
21412  }
21413  arg3 = static_cast< std::ios_base::seekdir >(val3);
21414  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->seekp(arg2,arg3);
21415  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21416  return resultobj;
21417 fail:
21418  return NULL;
21419 }
21420 
21421 
21422 SWIGINTERN PyObject *_wrap_ostream_seekp(PyObject *self, PyObject *args) {
21423  Py_ssize_t argc;
21424  PyObject *argv[4] = {
21425  0
21426  };
21427  Py_ssize_t ii;
21428 
21429  if (!PyTuple_Check(args)) SWIG_fail;
21430  argc = args ? PyObject_Length(args) : 0;
21431  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
21432  argv[ii] = PyTuple_GET_ITEM(args,ii);
21433  }
21434  if (argc == 2) {
21435  int _v;
21436  void *vptr = 0;
21437  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21438  _v = SWIG_CheckState(res);
21439  if (_v) {
21440  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streampos, 0);
21441  _v = SWIG_CheckState(res);
21442  if (_v) {
21443  return _wrap_ostream_seekp__SWIG_0(self, args);
21444  }
21445  }
21446  }
21447  if (argc == 3) {
21448  int _v;
21449  void *vptr = 0;
21450  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
21451  _v = SWIG_CheckState(res);
21452  if (_v) {
21453  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streamoff, 0);
21454  _v = SWIG_CheckState(res);
21455  if (_v) {
21456  {
21457  int res = SWIG_AsVal_int(argv[2], NULL);
21458  _v = SWIG_CheckState(res);
21459  }
21460  if (_v) {
21461  return _wrap_ostream_seekp__SWIG_1(self, args);
21462  }
21463  }
21464  }
21465  }
21466 
21467 fail:
21468  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ostream_seekp'.\n"
21469  " Possible C/C++ prototypes are:\n"
21470  " std::basic_ostream< char >::seekp(std::basic_ostream< char >::pos_type)\n"
21471  " std::basic_ostream< char >::seekp(std::basic_ostream< char >::off_type,std::ios_base::seekdir)\n");
21472  return 0;
21473 }
21474 
21475 
21476 SWIGINTERN PyObject *ostream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21477  PyObject *obj;
21478  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
21479  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
21480  return SWIG_Py_Void();
21481 }
21482 
21483 SWIGINTERN PyObject *_wrap_new_istream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21484  PyObject *resultobj = 0;
21485  std::basic_streambuf< char,std::char_traits< char > > *arg1 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
21486  void *argp1 = 0 ;
21487  int res1 = 0 ;
21488  PyObject * obj0 = 0 ;
21489  std::basic_istream< char > *result = 0 ;
21490 
21491  if (!PyArg_ParseTuple(args,(char *)"O:new_istream",&obj0)) SWIG_fail;
21492  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
21493  if (!SWIG_IsOK(res1)) {
21494  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_istream" "', argument " "1"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'");
21495  }
21496  arg1 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp1);
21497  result = (std::basic_istream< char > *)new std::basic_istream< char >(arg1);
21498  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NEW | 0 );
21499  return resultobj;
21500 fail:
21501  return NULL;
21502 }
21503 
21504 
21505 SWIGINTERN PyObject *_wrap_delete_istream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21506  PyObject *resultobj = 0;
21507  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21508  void *argp1 = 0 ;
21509  int res1 = 0 ;
21510  PyObject * obj0 = 0 ;
21511 
21512  if (!PyArg_ParseTuple(args,(char *)"O:delete_istream",&obj0)) SWIG_fail;
21513  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN | 0 );
21514  if (!SWIG_IsOK(res1)) {
21515  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_istream" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21516  }
21517  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21518  delete arg1;
21519  resultobj = SWIG_Py_Void();
21520  return resultobj;
21521 fail:
21522  return NULL;
21523 }
21524 
21525 
21526 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21527  PyObject *resultobj = 0;
21528  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21529  std::basic_istream< char,std::char_traits< char > > &(*arg2)(std::basic_istream< char,std::char_traits< char > > &) = (std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &)) 0 ;
21530  void *argp1 = 0 ;
21531  int res1 = 0 ;
21532  PyObject * obj0 = 0 ;
21533  PyObject * obj1 = 0 ;
21534  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21535 
21536  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21537  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21538  if (!SWIG_IsOK(res1)) {
21539  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21540  }
21541  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21542  {
21543  int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t);
21544  if (!SWIG_IsOK(res)) {
21545  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "istream___rshift__" "', argument " "2"" of type '" "std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &)""'");
21546  }
21547  }
21548  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(arg2);
21549  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21550  return resultobj;
21551 fail:
21552  return NULL;
21553 }
21554 
21555 
21556 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21557  PyObject *resultobj = 0;
21558  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21559  std::basic_ios< char,std::char_traits< char > > &(*arg2)(std::basic_ios< char,std::char_traits< char > > &) = (std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) 0 ;
21560  void *argp1 = 0 ;
21561  int res1 = 0 ;
21562  PyObject * obj0 = 0 ;
21563  PyObject * obj1 = 0 ;
21564  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21565 
21566  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21567  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21568  if (!SWIG_IsOK(res1)) {
21569  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21570  }
21571  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21572  {
21573  int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t);
21574  if (!SWIG_IsOK(res)) {
21575  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "istream___rshift__" "', argument " "2"" of type '" "std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)""'");
21576  }
21577  }
21578  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(arg2);
21579  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21580  return resultobj;
21581 fail:
21582  return NULL;
21583 }
21584 
21585 
21586 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21587  PyObject *resultobj = 0;
21588  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21589  std::ios_base &(*arg2)(std::ios_base &) = (std::ios_base &(*)(std::ios_base &)) 0 ;
21590  void *argp1 = 0 ;
21591  int res1 = 0 ;
21592  PyObject * obj0 = 0 ;
21593  PyObject * obj1 = 0 ;
21594  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21595 
21596  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21597  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21598  if (!SWIG_IsOK(res1)) {
21599  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21600  }
21601  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21602  {
21603  int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base);
21604  if (!SWIG_IsOK(res)) {
21605  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "istream___rshift__" "', argument " "2"" of type '" "std::ios_base &(*)(std::ios_base &)""'");
21606  }
21607  }
21608  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(arg2);
21609  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21610  return resultobj;
21611 fail:
21612  return NULL;
21613 }
21614 
21615 
21616 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21617  PyObject *resultobj = 0;
21618  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21619  bool *arg2 = 0 ;
21620  void *argp1 = 0 ;
21621  int res1 = 0 ;
21622  void *argp2 = 0 ;
21623  int res2 = 0 ;
21624  PyObject * obj0 = 0 ;
21625  PyObject * obj1 = 0 ;
21626  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21627 
21628  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21629  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21630  if (!SWIG_IsOK(res1)) {
21631  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21632  }
21633  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21634  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool, 0 );
21635  if (!SWIG_IsOK(res2)) {
21636  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "bool &""'");
21637  }
21638  if (!argp2) {
21639  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "bool &""'");
21640  }
21641  arg2 = reinterpret_cast< bool * >(argp2);
21642  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21643  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21644  return resultobj;
21645 fail:
21646  return NULL;
21647 }
21648 
21649 
21650 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21651  PyObject *resultobj = 0;
21652  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21653  short *arg2 = 0 ;
21654  void *argp1 = 0 ;
21655  int res1 = 0 ;
21656  void *argp2 = 0 ;
21657  int res2 = 0 ;
21658  PyObject * obj0 = 0 ;
21659  PyObject * obj1 = 0 ;
21660  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21661 
21662  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21663  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21664  if (!SWIG_IsOK(res1)) {
21665  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21666  }
21667  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21668  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_short, 0 );
21669  if (!SWIG_IsOK(res2)) {
21670  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "short &""'");
21671  }
21672  if (!argp2) {
21673  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "short &""'");
21674  }
21675  arg2 = reinterpret_cast< short * >(argp2);
21676  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21677  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21678  return resultobj;
21679 fail:
21680  return NULL;
21681 }
21682 
21683 
21684 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21685  PyObject *resultobj = 0;
21686  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21687  unsigned short *arg2 = 0 ;
21688  void *argp1 = 0 ;
21689  int res1 = 0 ;
21690  void *argp2 = 0 ;
21691  int res2 = 0 ;
21692  PyObject * obj0 = 0 ;
21693  PyObject * obj1 = 0 ;
21694  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21695 
21696  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21697  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21698  if (!SWIG_IsOK(res1)) {
21699  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21700  }
21701  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21702  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_unsigned_short, 0 );
21703  if (!SWIG_IsOK(res2)) {
21704  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned short &""'");
21705  }
21706  if (!argp2) {
21707  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned short &""'");
21708  }
21709  arg2 = reinterpret_cast< unsigned short * >(argp2);
21710  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21711  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21712  return resultobj;
21713 fail:
21714  return NULL;
21715 }
21716 
21717 
21718 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21719  PyObject *resultobj = 0;
21720  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21721  int *arg2 = 0 ;
21722  void *argp1 = 0 ;
21723  int res1 = 0 ;
21724  void *argp2 = 0 ;
21725  int res2 = 0 ;
21726  PyObject * obj0 = 0 ;
21727  PyObject * obj1 = 0 ;
21728  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21729 
21730  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21731  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21732  if (!SWIG_IsOK(res1)) {
21733  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21734  }
21735  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21736  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 );
21737  if (!SWIG_IsOK(res2)) {
21738  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "int &""'");
21739  }
21740  if (!argp2) {
21741  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "int &""'");
21742  }
21743  arg2 = reinterpret_cast< int * >(argp2);
21744  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21745  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21746  return resultobj;
21747 fail:
21748  return NULL;
21749 }
21750 
21751 
21752 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21753  PyObject *resultobj = 0;
21754  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21755  unsigned int *arg2 = 0 ;
21756  void *argp1 = 0 ;
21757  int res1 = 0 ;
21758  void *argp2 = 0 ;
21759  int res2 = 0 ;
21760  PyObject * obj0 = 0 ;
21761  PyObject * obj1 = 0 ;
21762  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21763 
21764  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21765  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21766  if (!SWIG_IsOK(res1)) {
21767  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21768  }
21769  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21770  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_unsigned_int, 0 );
21771  if (!SWIG_IsOK(res2)) {
21772  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned int &""'");
21773  }
21774  if (!argp2) {
21775  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned int &""'");
21776  }
21777  arg2 = reinterpret_cast< unsigned int * >(argp2);
21778  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21779  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21780  return resultobj;
21781 fail:
21782  return NULL;
21783 }
21784 
21785 
21786 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21787  PyObject *resultobj = 0;
21788  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21789  long *arg2 = 0 ;
21790  void *argp1 = 0 ;
21791  int res1 = 0 ;
21792  void *argp2 = 0 ;
21793  int res2 = 0 ;
21794  PyObject * obj0 = 0 ;
21795  PyObject * obj1 = 0 ;
21796  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21797 
21798  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21799  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21800  if (!SWIG_IsOK(res1)) {
21801  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21802  }
21803  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21804  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long, 0 );
21805  if (!SWIG_IsOK(res2)) {
21806  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "long &""'");
21807  }
21808  if (!argp2) {
21809  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "long &""'");
21810  }
21811  arg2 = reinterpret_cast< long * >(argp2);
21812  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21813  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21814  return resultobj;
21815 fail:
21816  return NULL;
21817 }
21818 
21819 
21820 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21821  PyObject *resultobj = 0;
21822  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21823  unsigned long *arg2 = 0 ;
21824  void *argp1 = 0 ;
21825  int res1 = 0 ;
21826  void *argp2 = 0 ;
21827  int res2 = 0 ;
21828  PyObject * obj0 = 0 ;
21829  PyObject * obj1 = 0 ;
21830  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21831 
21832  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21833  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21834  if (!SWIG_IsOK(res1)) {
21835  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21836  }
21837  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21838  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_unsigned_long, 0 );
21839  if (!SWIG_IsOK(res2)) {
21840  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned long &""'");
21841  }
21842  if (!argp2) {
21843  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned long &""'");
21844  }
21845  arg2 = reinterpret_cast< unsigned long * >(argp2);
21846  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21847  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21848  return resultobj;
21849 fail:
21850  return NULL;
21851 }
21852 
21853 
21854 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21855  PyObject *resultobj = 0;
21856  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21857  long long *arg2 = 0 ;
21858  void *argp1 = 0 ;
21859  int res1 = 0 ;
21860  void *argp2 = 0 ;
21861  int res2 = 0 ;
21862  PyObject * obj0 = 0 ;
21863  PyObject * obj1 = 0 ;
21864  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21865 
21866  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21867  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21868  if (!SWIG_IsOK(res1)) {
21869  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21870  }
21871  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21872  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long_long, 0 );
21873  if (!SWIG_IsOK(res2)) {
21874  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "long long &""'");
21875  }
21876  if (!argp2) {
21877  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "long long &""'");
21878  }
21879  arg2 = reinterpret_cast< long long * >(argp2);
21880  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21881  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21882  return resultobj;
21883 fail:
21884  return NULL;
21885 }
21886 
21887 
21888 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21889  PyObject *resultobj = 0;
21890  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21891  unsigned long long *arg2 = 0 ;
21892  void *argp1 = 0 ;
21893  int res1 = 0 ;
21894  void *argp2 = 0 ;
21895  int res2 = 0 ;
21896  PyObject * obj0 = 0 ;
21897  PyObject * obj1 = 0 ;
21898  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21899 
21900  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21901  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21902  if (!SWIG_IsOK(res1)) {
21903  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21904  }
21905  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21906  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_unsigned_long_long, 0 );
21907  if (!SWIG_IsOK(res2)) {
21908  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned long long &""'");
21909  }
21910  if (!argp2) {
21911  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned long long &""'");
21912  }
21913  arg2 = reinterpret_cast< unsigned long long * >(argp2);
21914  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21915  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21916  return resultobj;
21917 fail:
21918  return NULL;
21919 }
21920 
21921 
21922 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21923  PyObject *resultobj = 0;
21924  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21925  float *arg2 = 0 ;
21926  void *argp1 = 0 ;
21927  int res1 = 0 ;
21928  void *argp2 = 0 ;
21929  int res2 = 0 ;
21930  PyObject * obj0 = 0 ;
21931  PyObject * obj1 = 0 ;
21932  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21933 
21934  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21935  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21936  if (!SWIG_IsOK(res1)) {
21937  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21938  }
21939  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21940  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_float, 0 );
21941  if (!SWIG_IsOK(res2)) {
21942  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "float &""'");
21943  }
21944  if (!argp2) {
21945  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "float &""'");
21946  }
21947  arg2 = reinterpret_cast< float * >(argp2);
21948  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21949  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21950  return resultobj;
21951 fail:
21952  return NULL;
21953 }
21954 
21955 
21956 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21957  PyObject *resultobj = 0;
21958  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21959  double *arg2 = 0 ;
21960  void *argp1 = 0 ;
21961  int res1 = 0 ;
21962  void *argp2 = 0 ;
21963  int res2 = 0 ;
21964  PyObject * obj0 = 0 ;
21965  PyObject * obj1 = 0 ;
21966  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
21967 
21968  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
21969  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21970  if (!SWIG_IsOK(res1)) {
21971  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
21972  }
21973  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
21974  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double, 0 );
21975  if (!SWIG_IsOK(res2)) {
21976  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "double &""'");
21977  }
21978  if (!argp2) {
21979  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "double &""'");
21980  }
21981  arg2 = reinterpret_cast< double * >(argp2);
21982  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
21983  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
21984  return resultobj;
21985 fail:
21986  return NULL;
21987 }
21988 
21989 
21990 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21991  PyObject *resultobj = 0;
21992  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
21993  long double *arg2 = 0 ;
21994  void *argp1 = 0 ;
21995  int res1 = 0 ;
21996  void *argp2 = 0 ;
21997  int res2 = 0 ;
21998  PyObject * obj0 = 0 ;
21999  PyObject * obj1 = 0 ;
22000  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22001 
22002  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
22003  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22004  if (!SWIG_IsOK(res1)) {
22005  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22006  }
22007  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22008  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long_double, 0 );
22009  if (!SWIG_IsOK(res2)) {
22010  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "long double &""'");
22011  }
22012  if (!argp2) {
22013  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "long double &""'");
22014  }
22015  arg2 = reinterpret_cast< long double * >(argp2);
22016  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
22017  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22018  return resultobj;
22019 fail:
22020  return NULL;
22021 }
22022 
22023 
22024 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22025  PyObject *resultobj = 0;
22026  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22027  void **arg2 = 0 ;
22028  void *argp1 = 0 ;
22029  int res1 = 0 ;
22030  void *argp2 = 0 ;
22031  int res2 = 0 ;
22032  PyObject * obj0 = 0 ;
22033  PyObject * obj1 = 0 ;
22034  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22035 
22036  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
22037  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22038  if (!SWIG_IsOK(res1)) {
22039  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22040  }
22041  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22042  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_void, 0 );
22043  if (!SWIG_IsOK(res2)) {
22044  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "void *&""'");
22045  }
22046  if (!argp2) {
22047  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "void *&""'");
22048  }
22049  arg2 = reinterpret_cast< void ** >(argp2);
22050  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
22051  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22052  return resultobj;
22053 fail:
22054  return NULL;
22055 }
22056 
22057 
22058 SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22059  PyObject *resultobj = 0;
22060  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22061  std::basic_streambuf< char,std::char_traits< char > > *arg2 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
22062  void *argp1 = 0 ;
22063  int res1 = 0 ;
22064  void *argp2 = 0 ;
22065  int res2 = 0 ;
22066  PyObject * obj0 = 0 ;
22067  PyObject * obj1 = 0 ;
22068  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22069 
22070  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
22071  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22072  if (!SWIG_IsOK(res1)) {
22073  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22074  }
22075  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22076  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
22077  if (!SWIG_IsOK(res2)) {
22078  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'");
22079  }
22080  arg2 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp2);
22081  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(arg2);
22082  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22083  return resultobj;
22084 fail:
22085  return NULL;
22086 }
22087 
22088 
22089 SWIGINTERN PyObject *_wrap_istream___rshift__(PyObject *self, PyObject *args) {
22090  Py_ssize_t argc;
22091  PyObject *argv[3] = {
22092  0
22093  };
22094  Py_ssize_t ii;
22095 
22096  if (!PyTuple_Check(args)) SWIG_fail;
22097  argc = args ? PyObject_Length(args) : 0;
22098  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
22099  argv[ii] = PyTuple_GET_ITEM(args,ii);
22100  }
22101  if (argc == 2) {
22102  int _v;
22103  void *vptr = 0;
22104  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22105  _v = SWIG_CheckState(res);
22106  if (_v) {
22107  void *ptr = 0;
22108  int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t);
22109  _v = SWIG_CheckState(res);
22110  if (_v) {
22111  return _wrap_istream___rshift____SWIG_0(self, args);
22112  }
22113  }
22114  }
22115  if (argc == 2) {
22116  int _v;
22117  void *vptr = 0;
22118  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22119  _v = SWIG_CheckState(res);
22120  if (_v) {
22121  void *ptr = 0;
22122  int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t);
22123  _v = SWIG_CheckState(res);
22124  if (_v) {
22125  return _wrap_istream___rshift____SWIG_1(self, args);
22126  }
22127  }
22128  }
22129  if (argc == 2) {
22130  int _v;
22131  void *vptr = 0;
22132  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22133  _v = SWIG_CheckState(res);
22134  if (_v) {
22135  void *ptr = 0;
22136  int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base);
22137  _v = SWIG_CheckState(res);
22138  if (_v) {
22139  return _wrap_istream___rshift____SWIG_2(self, args);
22140  }
22141  }
22142  }
22143  if (argc == 2) {
22144  int _v;
22145  void *vptr = 0;
22146  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22147  _v = SWIG_CheckState(res);
22148  if (_v) {
22149  void *vptr = 0;
22150  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bool, 0);
22151  _v = SWIG_CheckState(res);
22152  if (_v) {
22153  return _wrap_istream___rshift____SWIG_3(self, args);
22154  }
22155  }
22156  }
22157  if (argc == 2) {
22158  int _v;
22159  void *vptr = 0;
22160  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22161  _v = SWIG_CheckState(res);
22162  if (_v) {
22163  void *vptr = 0;
22164  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0);
22165  _v = SWIG_CheckState(res);
22166  if (_v) {
22167  return _wrap_istream___rshift____SWIG_4(self, args);
22168  }
22169  }
22170  }
22171  if (argc == 2) {
22172  int _v;
22173  void *vptr = 0;
22174  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22175  _v = SWIG_CheckState(res);
22176  if (_v) {
22177  void *vptr = 0;
22178  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
22179  _v = SWIG_CheckState(res);
22180  if (_v) {
22181  return _wrap_istream___rshift____SWIG_5(self, args);
22182  }
22183  }
22184  }
22185  if (argc == 2) {
22186  int _v;
22187  void *vptr = 0;
22188  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22189  _v = SWIG_CheckState(res);
22190  if (_v) {
22191  void *vptr = 0;
22192  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
22193  _v = SWIG_CheckState(res);
22194  if (_v) {
22195  return _wrap_istream___rshift____SWIG_6(self, args);
22196  }
22197  }
22198  }
22199  if (argc == 2) {
22200  int _v;
22201  void *vptr = 0;
22202  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22203  _v = SWIG_CheckState(res);
22204  if (_v) {
22205  void *vptr = 0;
22206  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
22207  _v = SWIG_CheckState(res);
22208  if (_v) {
22209  return _wrap_istream___rshift____SWIG_7(self, args);
22210  }
22211  }
22212  }
22213  if (argc == 2) {
22214  int _v;
22215  void *vptr = 0;
22216  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22217  _v = SWIG_CheckState(res);
22218  if (_v) {
22219  void *vptr = 0;
22220  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long, 0);
22221  _v = SWIG_CheckState(res);
22222  if (_v) {
22223  return _wrap_istream___rshift____SWIG_8(self, args);
22224  }
22225  }
22226  }
22227  if (argc == 2) {
22228  int _v;
22229  void *vptr = 0;
22230  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22231  _v = SWIG_CheckState(res);
22232  if (_v) {
22233  void *vptr = 0;
22234  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_long, 0);
22235  _v = SWIG_CheckState(res);
22236  if (_v) {
22237  return _wrap_istream___rshift____SWIG_9(self, args);
22238  }
22239  }
22240  }
22241  if (argc == 2) {
22242  int _v;
22243  void *vptr = 0;
22244  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22245  _v = SWIG_CheckState(res);
22246  if (_v) {
22247  void *vptr = 0;
22248  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_long, 0);
22249  _v = SWIG_CheckState(res);
22250  if (_v) {
22251  return _wrap_istream___rshift____SWIG_10(self, args);
22252  }
22253  }
22254  }
22255  if (argc == 2) {
22256  int _v;
22257  void *vptr = 0;
22258  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22259  _v = SWIG_CheckState(res);
22260  if (_v) {
22261  void *vptr = 0;
22262  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_long_long, 0);
22263  _v = SWIG_CheckState(res);
22264  if (_v) {
22265  return _wrap_istream___rshift____SWIG_11(self, args);
22266  }
22267  }
22268  }
22269  if (argc == 2) {
22270  int _v;
22271  void *vptr = 0;
22272  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22273  _v = SWIG_CheckState(res);
22274  if (_v) {
22275  void *vptr = 0;
22276  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
22277  _v = SWIG_CheckState(res);
22278  if (_v) {
22279  return _wrap_istream___rshift____SWIG_12(self, args);
22280  }
22281  }
22282  }
22283  if (argc == 2) {
22284  int _v;
22285  void *vptr = 0;
22286  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22287  _v = SWIG_CheckState(res);
22288  if (_v) {
22289  void *vptr = 0;
22290  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
22291  _v = SWIG_CheckState(res);
22292  if (_v) {
22293  return _wrap_istream___rshift____SWIG_13(self, args);
22294  }
22295  }
22296  }
22297  if (argc == 2) {
22298  int _v;
22299  void *vptr = 0;
22300  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22301  _v = SWIG_CheckState(res);
22302  if (_v) {
22303  void *vptr = 0;
22304  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_double, 0);
22305  _v = SWIG_CheckState(res);
22306  if (_v) {
22307  return _wrap_istream___rshift____SWIG_14(self, args);
22308  }
22309  }
22310  }
22311  if (argc == 2) {
22312  int _v;
22313  void *vptr = 0;
22314  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22315  _v = SWIG_CheckState(res);
22316  if (_v) {
22317  void *vptr = 0;
22318  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_void, 0);
22319  _v = SWIG_CheckState(res);
22320  if (_v) {
22321  return _wrap_istream___rshift____SWIG_15(self, args);
22322  }
22323  }
22324  }
22325  if (argc == 2) {
22326  int _v;
22327  void *vptr = 0;
22328  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22329  _v = SWIG_CheckState(res);
22330  if (_v) {
22331  void *vptr = 0;
22332  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
22333  _v = SWIG_CheckState(res);
22334  if (_v) {
22335  return _wrap_istream___rshift____SWIG_16(self, args);
22336  }
22337  }
22338  }
22339 
22340 fail:
22341  Py_INCREF(Py_NotImplemented);
22342  return Py_NotImplemented;
22343 }
22344 
22345 
22346 SWIGINTERN PyObject *_wrap_istream_gcount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22347  PyObject *resultobj = 0;
22348  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22349  void *argp1 = 0 ;
22350  int res1 = 0 ;
22351  PyObject * obj0 = 0 ;
22352  std::streamsize result;
22353 
22354  if (!PyArg_ParseTuple(args,(char *)"O:istream_gcount",&obj0)) SWIG_fail;
22355  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22356  if (!SWIG_IsOK(res1)) {
22357  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_gcount" "', argument " "1"" of type '" "std::basic_istream< char > const *""'");
22358  }
22359  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22360  result = ((std::basic_istream< char > const *)arg1)->gcount();
22361  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
22362  return resultobj;
22363 fail:
22364  return NULL;
22365 }
22366 
22367 
22368 SWIGINTERN PyObject *_wrap_istream_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22369  PyObject *resultobj = 0;
22370  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22371  void *argp1 = 0 ;
22372  int res1 = 0 ;
22373  PyObject * obj0 = 0 ;
22374  std::basic_istream< char >::int_type result;
22375 
22376  if (!PyArg_ParseTuple(args,(char *)"O:istream_get",&obj0)) SWIG_fail;
22377  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22378  if (!SWIG_IsOK(res1)) {
22379  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22380  }
22381  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22382  result = (std::basic_istream< char >::int_type)(arg1)->get();
22383  resultobj = SWIG_From_int(static_cast< int >(result));
22384  return resultobj;
22385 fail:
22386  return NULL;
22387 }
22388 
22389 
22390 SWIGINTERN PyObject *_wrap_istream_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22391  PyObject *resultobj = 0;
22392  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22393  std::basic_istream< char >::char_type *arg2 = 0 ;
22394  void *argp1 = 0 ;
22395  int res1 = 0 ;
22396  void *argp2 = 0 ;
22397  int res2 = 0 ;
22398  PyObject * obj0 = 0 ;
22399  PyObject * obj1 = 0 ;
22400  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22401 
22402  if (!PyArg_ParseTuple(args,(char *)"OO:istream_get",&obj0,&obj1)) SWIG_fail;
22403  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22404  if (!SWIG_IsOK(res1)) {
22405  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22406  }
22407  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22408  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_char, 0 );
22409  if (!SWIG_IsOK(res2)) {
22410  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_istream< char >::char_type &""'");
22411  }
22412  if (!argp2) {
22413  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_istream< char >::char_type &""'");
22414  }
22415  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(argp2);
22416  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->get(*arg2);
22417  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22418  return resultobj;
22419 fail:
22420  return NULL;
22421 }
22422 
22423 
22424 SWIGINTERN PyObject *_wrap_istream_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22425  PyObject *resultobj = 0;
22426  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22427  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
22428  std::streamsize arg3 ;
22429  std::basic_istream< char >::char_type arg4 ;
22430  void *argp1 = 0 ;
22431  int res1 = 0 ;
22432  int res2 ;
22433  char *buf2 = 0 ;
22434  int alloc2 = 0 ;
22435  size_t val3 ;
22436  int ecode3 = 0 ;
22437  char val4 ;
22438  int ecode4 = 0 ;
22439  PyObject * obj0 = 0 ;
22440  PyObject * obj1 = 0 ;
22441  PyObject * obj2 = 0 ;
22442  PyObject * obj3 = 0 ;
22443  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22444 
22445  if (!PyArg_ParseTuple(args,(char *)"OOOO:istream_get",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22446  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22447  if (!SWIG_IsOK(res1)) {
22448  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22449  }
22450  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22451  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22452  if (!SWIG_IsOK(res2)) {
22453  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
22454  }
22455  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
22456  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
22457  if (!SWIG_IsOK(ecode3)) {
22458  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_get" "', argument " "3"" of type '" "std::streamsize""'");
22459  }
22460  arg3 = static_cast< std::streamsize >(val3);
22461  ecode4 = SWIG_AsVal_char(obj3, &val4);
22462  if (!SWIG_IsOK(ecode4)) {
22463  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "istream_get" "', argument " "4"" of type '" "std::basic_istream< char >::char_type""'");
22464  }
22465  arg4 = static_cast< std::basic_istream< char >::char_type >(val4);
22466  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->get(arg2,arg3,arg4);
22467  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22468  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22469  return resultobj;
22470 fail:
22471  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22472  return NULL;
22473 }
22474 
22475 
22476 SWIGINTERN PyObject *_wrap_istream_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22477  PyObject *resultobj = 0;
22478  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22479  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
22480  std::streamsize arg3 ;
22481  void *argp1 = 0 ;
22482  int res1 = 0 ;
22483  int res2 ;
22484  char *buf2 = 0 ;
22485  int alloc2 = 0 ;
22486  size_t val3 ;
22487  int ecode3 = 0 ;
22488  PyObject * obj0 = 0 ;
22489  PyObject * obj1 = 0 ;
22490  PyObject * obj2 = 0 ;
22491  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22492 
22493  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_get",&obj0,&obj1,&obj2)) SWIG_fail;
22494  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22495  if (!SWIG_IsOK(res1)) {
22496  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22497  }
22498  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22499  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22500  if (!SWIG_IsOK(res2)) {
22501  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
22502  }
22503  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
22504  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
22505  if (!SWIG_IsOK(ecode3)) {
22506  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_get" "', argument " "3"" of type '" "std::streamsize""'");
22507  }
22508  arg3 = static_cast< std::streamsize >(val3);
22509  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->get(arg2,arg3);
22510  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22511  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22512  return resultobj;
22513 fail:
22514  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22515  return NULL;
22516 }
22517 
22518 
22519 SWIGINTERN PyObject *_wrap_istream_get__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22520  PyObject *resultobj = 0;
22521  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22522  std::basic_streambuf< char,std::char_traits< char > > *arg2 = 0 ;
22523  std::basic_istream< char >::char_type arg3 ;
22524  void *argp1 = 0 ;
22525  int res1 = 0 ;
22526  void *argp2 = 0 ;
22527  int res2 = 0 ;
22528  char val3 ;
22529  int ecode3 = 0 ;
22530  PyObject * obj0 = 0 ;
22531  PyObject * obj1 = 0 ;
22532  PyObject * obj2 = 0 ;
22533  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22534 
22535  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_get",&obj0,&obj1,&obj2)) SWIG_fail;
22536  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22537  if (!SWIG_IsOK(res1)) {
22538  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22539  }
22540  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22541  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 );
22542  if (!SWIG_IsOK(res2)) {
22543  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > &""'");
22544  }
22545  if (!argp2) {
22546  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > &""'");
22547  }
22548  arg2 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp2);
22549  ecode3 = SWIG_AsVal_char(obj2, &val3);
22550  if (!SWIG_IsOK(ecode3)) {
22551  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_get" "', argument " "3"" of type '" "std::basic_istream< char >::char_type""'");
22552  }
22553  arg3 = static_cast< std::basic_istream< char >::char_type >(val3);
22554  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->get(*arg2,arg3);
22555  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22556  return resultobj;
22557 fail:
22558  return NULL;
22559 }
22560 
22561 
22562 SWIGINTERN PyObject *_wrap_istream_get__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22563  PyObject *resultobj = 0;
22564  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22565  std::basic_streambuf< char,std::char_traits< char > > *arg2 = 0 ;
22566  void *argp1 = 0 ;
22567  int res1 = 0 ;
22568  void *argp2 = 0 ;
22569  int res2 = 0 ;
22570  PyObject * obj0 = 0 ;
22571  PyObject * obj1 = 0 ;
22572  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22573 
22574  if (!PyArg_ParseTuple(args,(char *)"OO:istream_get",&obj0,&obj1)) SWIG_fail;
22575  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22576  if (!SWIG_IsOK(res1)) {
22577  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22578  }
22579  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22580  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 );
22581  if (!SWIG_IsOK(res2)) {
22582  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > &""'");
22583  }
22584  if (!argp2) {
22585  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > &""'");
22586  }
22587  arg2 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp2);
22588  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->get(*arg2);
22589  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22590  return resultobj;
22591 fail:
22592  return NULL;
22593 }
22594 
22595 
22596 SWIGINTERN PyObject *_wrap_istream_get(PyObject *self, PyObject *args) {
22597  Py_ssize_t argc;
22598  PyObject *argv[5] = {
22599  0
22600  };
22601  Py_ssize_t ii;
22602 
22603  if (!PyTuple_Check(args)) SWIG_fail;
22604  argc = args ? PyObject_Length(args) : 0;
22605  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
22606  argv[ii] = PyTuple_GET_ITEM(args,ii);
22607  }
22608  if (argc == 1) {
22609  int _v;
22610  void *vptr = 0;
22611  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22612  _v = SWIG_CheckState(res);
22613  if (_v) {
22614  return _wrap_istream_get__SWIG_0(self, args);
22615  }
22616  }
22617  if (argc == 2) {
22618  int _v;
22619  void *vptr = 0;
22620  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22621  _v = SWIG_CheckState(res);
22622  if (_v) {
22623  void *vptr = 0;
22624  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_char, 0);
22625  _v = SWIG_CheckState(res);
22626  if (_v) {
22627  return _wrap_istream_get__SWIG_1(self, args);
22628  }
22629  }
22630  }
22631  if (argc == 2) {
22632  int _v;
22633  void *vptr = 0;
22634  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22635  _v = SWIG_CheckState(res);
22636  if (_v) {
22637  void *vptr = 0;
22638  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
22639  _v = SWIG_CheckState(res);
22640  if (_v) {
22641  return _wrap_istream_get__SWIG_5(self, args);
22642  }
22643  }
22644  }
22645  if (argc == 3) {
22646  int _v;
22647  void *vptr = 0;
22648  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22649  _v = SWIG_CheckState(res);
22650  if (_v) {
22651  void *vptr = 0;
22652  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
22653  _v = SWIG_CheckState(res);
22654  if (_v) {
22655  {
22656  int res = SWIG_AsVal_char(argv[2], NULL);
22657  _v = SWIG_CheckState(res);
22658  }
22659  if (_v) {
22660  return _wrap_istream_get__SWIG_4(self, args);
22661  }
22662  }
22663  }
22664  }
22665  if (argc == 3) {
22666  int _v;
22667  void *vptr = 0;
22668  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22669  _v = SWIG_CheckState(res);
22670  if (_v) {
22671  int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
22672  _v = SWIG_CheckState(res);
22673  if (_v) {
22674  {
22675  int res = SWIG_AsVal_size_t(argv[2], NULL);
22676  _v = SWIG_CheckState(res);
22677  }
22678  if (_v) {
22679  return _wrap_istream_get__SWIG_3(self, args);
22680  }
22681  }
22682  }
22683  }
22684  if (argc == 4) {
22685  int _v;
22686  void *vptr = 0;
22687  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22688  _v = SWIG_CheckState(res);
22689  if (_v) {
22690  int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
22691  _v = SWIG_CheckState(res);
22692  if (_v) {
22693  {
22694  int res = SWIG_AsVal_size_t(argv[2], NULL);
22695  _v = SWIG_CheckState(res);
22696  }
22697  if (_v) {
22698  {
22699  int res = SWIG_AsVal_char(argv[3], NULL);
22700  _v = SWIG_CheckState(res);
22701  }
22702  if (_v) {
22703  return _wrap_istream_get__SWIG_2(self, args);
22704  }
22705  }
22706  }
22707  }
22708  }
22709 
22710 fail:
22711  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'istream_get'.\n"
22712  " Possible C/C++ prototypes are:\n"
22713  " std::basic_istream< char >::get()\n"
22714  " std::basic_istream< char >::get(std::basic_istream< char >::char_type &)\n"
22715  " std::basic_istream< char >::get(std::basic_istream< char >::char_type *,std::streamsize,std::basic_istream< char >::char_type)\n"
22716  " std::basic_istream< char >::get(std::basic_istream< char >::char_type *,std::streamsize)\n"
22717  " std::basic_istream< char >::get(std::basic_streambuf< char,std::char_traits< char > > &,std::basic_istream< char >::char_type)\n"
22718  " std::basic_istream< char >::get(std::basic_streambuf< char,std::char_traits< char > > &)\n");
22719  return 0;
22720 }
22721 
22722 
22723 SWIGINTERN PyObject *_wrap_istream_getline__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22724  PyObject *resultobj = 0;
22725  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22726  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
22727  std::streamsize arg3 ;
22728  std::basic_istream< char >::char_type arg4 ;
22729  void *argp1 = 0 ;
22730  int res1 = 0 ;
22731  int res2 ;
22732  char *buf2 = 0 ;
22733  int alloc2 = 0 ;
22734  size_t val3 ;
22735  int ecode3 = 0 ;
22736  char val4 ;
22737  int ecode4 = 0 ;
22738  PyObject * obj0 = 0 ;
22739  PyObject * obj1 = 0 ;
22740  PyObject * obj2 = 0 ;
22741  PyObject * obj3 = 0 ;
22742  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22743 
22744  if (!PyArg_ParseTuple(args,(char *)"OOOO:istream_getline",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22745  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22746  if (!SWIG_IsOK(res1)) {
22747  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_getline" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22748  }
22749  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22750  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22751  if (!SWIG_IsOK(res2)) {
22752  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_getline" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
22753  }
22754  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
22755  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
22756  if (!SWIG_IsOK(ecode3)) {
22757  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_getline" "', argument " "3"" of type '" "std::streamsize""'");
22758  }
22759  arg3 = static_cast< std::streamsize >(val3);
22760  ecode4 = SWIG_AsVal_char(obj3, &val4);
22761  if (!SWIG_IsOK(ecode4)) {
22762  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "istream_getline" "', argument " "4"" of type '" "std::basic_istream< char >::char_type""'");
22763  }
22764  arg4 = static_cast< std::basic_istream< char >::char_type >(val4);
22765  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->getline(arg2,arg3,arg4);
22766  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22767  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22768  return resultobj;
22769 fail:
22770  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22771  return NULL;
22772 }
22773 
22774 
22775 SWIGINTERN PyObject *_wrap_istream_getline__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22776  PyObject *resultobj = 0;
22777  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22778  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
22779  std::streamsize arg3 ;
22780  void *argp1 = 0 ;
22781  int res1 = 0 ;
22782  int res2 ;
22783  char *buf2 = 0 ;
22784  int alloc2 = 0 ;
22785  size_t val3 ;
22786  int ecode3 = 0 ;
22787  PyObject * obj0 = 0 ;
22788  PyObject * obj1 = 0 ;
22789  PyObject * obj2 = 0 ;
22790  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22791 
22792  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_getline",&obj0,&obj1,&obj2)) SWIG_fail;
22793  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22794  if (!SWIG_IsOK(res1)) {
22795  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_getline" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22796  }
22797  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22798  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22799  if (!SWIG_IsOK(res2)) {
22800  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_getline" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
22801  }
22802  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
22803  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
22804  if (!SWIG_IsOK(ecode3)) {
22805  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_getline" "', argument " "3"" of type '" "std::streamsize""'");
22806  }
22807  arg3 = static_cast< std::streamsize >(val3);
22808  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->getline(arg2,arg3);
22809  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22810  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22811  return resultobj;
22812 fail:
22813  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22814  return NULL;
22815 }
22816 
22817 
22818 SWIGINTERN PyObject *_wrap_istream_getline(PyObject *self, PyObject *args) {
22819  Py_ssize_t argc;
22820  PyObject *argv[5] = {
22821  0
22822  };
22823  Py_ssize_t ii;
22824 
22825  if (!PyTuple_Check(args)) SWIG_fail;
22826  argc = args ? PyObject_Length(args) : 0;
22827  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
22828  argv[ii] = PyTuple_GET_ITEM(args,ii);
22829  }
22830  if (argc == 3) {
22831  int _v;
22832  void *vptr = 0;
22833  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22834  _v = SWIG_CheckState(res);
22835  if (_v) {
22836  int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
22837  _v = SWIG_CheckState(res);
22838  if (_v) {
22839  {
22840  int res = SWIG_AsVal_size_t(argv[2], NULL);
22841  _v = SWIG_CheckState(res);
22842  }
22843  if (_v) {
22844  return _wrap_istream_getline__SWIG_1(self, args);
22845  }
22846  }
22847  }
22848  }
22849  if (argc == 4) {
22850  int _v;
22851  void *vptr = 0;
22852  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22853  _v = SWIG_CheckState(res);
22854  if (_v) {
22855  int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
22856  _v = SWIG_CheckState(res);
22857  if (_v) {
22858  {
22859  int res = SWIG_AsVal_size_t(argv[2], NULL);
22860  _v = SWIG_CheckState(res);
22861  }
22862  if (_v) {
22863  {
22864  int res = SWIG_AsVal_char(argv[3], NULL);
22865  _v = SWIG_CheckState(res);
22866  }
22867  if (_v) {
22868  return _wrap_istream_getline__SWIG_0(self, args);
22869  }
22870  }
22871  }
22872  }
22873  }
22874 
22875 fail:
22876  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'istream_getline'.\n"
22877  " Possible C/C++ prototypes are:\n"
22878  " std::basic_istream< char >::getline(std::basic_istream< char >::char_type *,std::streamsize,std::basic_istream< char >::char_type)\n"
22879  " std::basic_istream< char >::getline(std::basic_istream< char >::char_type *,std::streamsize)\n");
22880  return 0;
22881 }
22882 
22883 
22884 SWIGINTERN PyObject *_wrap_istream_ignore__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22885  PyObject *resultobj = 0;
22886  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22887  std::streamsize arg2 ;
22888  std::basic_istream< char >::int_type arg3 ;
22889  void *argp1 = 0 ;
22890  int res1 = 0 ;
22891  size_t val2 ;
22892  int ecode2 = 0 ;
22893  int val3 ;
22894  int ecode3 = 0 ;
22895  PyObject * obj0 = 0 ;
22896  PyObject * obj1 = 0 ;
22897  PyObject * obj2 = 0 ;
22898  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22899 
22900  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_ignore",&obj0,&obj1,&obj2)) SWIG_fail;
22901  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22902  if (!SWIG_IsOK(res1)) {
22903  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_ignore" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22904  }
22905  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22906  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
22907  if (!SWIG_IsOK(ecode2)) {
22908  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "istream_ignore" "', argument " "2"" of type '" "std::streamsize""'");
22909  }
22910  arg2 = static_cast< std::streamsize >(val2);
22911  ecode3 = SWIG_AsVal_int(obj2, &val3);
22912  if (!SWIG_IsOK(ecode3)) {
22913  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_ignore" "', argument " "3"" of type '" "std::basic_istream< char >::int_type""'");
22914  }
22915  arg3 = static_cast< std::basic_istream< char >::int_type >(val3);
22916  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->ignore(arg2,arg3);
22917  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22918  return resultobj;
22919 fail:
22920  return NULL;
22921 }
22922 
22923 
22924 SWIGINTERN PyObject *_wrap_istream_ignore__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22925  PyObject *resultobj = 0;
22926  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22927  std::streamsize arg2 ;
22928  void *argp1 = 0 ;
22929  int res1 = 0 ;
22930  size_t val2 ;
22931  int ecode2 = 0 ;
22932  PyObject * obj0 = 0 ;
22933  PyObject * obj1 = 0 ;
22934  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22935 
22936  if (!PyArg_ParseTuple(args,(char *)"OO:istream_ignore",&obj0,&obj1)) SWIG_fail;
22937  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22938  if (!SWIG_IsOK(res1)) {
22939  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_ignore" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22940  }
22941  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22942  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
22943  if (!SWIG_IsOK(ecode2)) {
22944  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "istream_ignore" "', argument " "2"" of type '" "std::streamsize""'");
22945  }
22946  arg2 = static_cast< std::streamsize >(val2);
22947  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->ignore(arg2);
22948  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22949  return resultobj;
22950 fail:
22951  return NULL;
22952 }
22953 
22954 
22955 SWIGINTERN PyObject *_wrap_istream_ignore__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22956  PyObject *resultobj = 0;
22957  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
22958  void *argp1 = 0 ;
22959  int res1 = 0 ;
22960  PyObject * obj0 = 0 ;
22961  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
22962 
22963  if (!PyArg_ParseTuple(args,(char *)"O:istream_ignore",&obj0)) SWIG_fail;
22964  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22965  if (!SWIG_IsOK(res1)) {
22966  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_ignore" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
22967  }
22968  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
22969  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->ignore();
22970  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
22971  return resultobj;
22972 fail:
22973  return NULL;
22974 }
22975 
22976 
22977 SWIGINTERN PyObject *_wrap_istream_ignore(PyObject *self, PyObject *args) {
22978  Py_ssize_t argc;
22979  PyObject *argv[4] = {
22980  0
22981  };
22982  Py_ssize_t ii;
22983 
22984  if (!PyTuple_Check(args)) SWIG_fail;
22985  argc = args ? PyObject_Length(args) : 0;
22986  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
22987  argv[ii] = PyTuple_GET_ITEM(args,ii);
22988  }
22989  if (argc == 1) {
22990  int _v;
22991  void *vptr = 0;
22992  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
22993  _v = SWIG_CheckState(res);
22994  if (_v) {
22995  return _wrap_istream_ignore__SWIG_2(self, args);
22996  }
22997  }
22998  if (argc == 2) {
22999  int _v;
23000  void *vptr = 0;
23001  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
23002  _v = SWIG_CheckState(res);
23003  if (_v) {
23004  {
23005  int res = SWIG_AsVal_size_t(argv[1], NULL);
23006  _v = SWIG_CheckState(res);
23007  }
23008  if (_v) {
23009  return _wrap_istream_ignore__SWIG_1(self, args);
23010  }
23011  }
23012  }
23013  if (argc == 3) {
23014  int _v;
23015  void *vptr = 0;
23016  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
23017  _v = SWIG_CheckState(res);
23018  if (_v) {
23019  {
23020  int res = SWIG_AsVal_size_t(argv[1], NULL);
23021  _v = SWIG_CheckState(res);
23022  }
23023  if (_v) {
23024  {
23025  int res = SWIG_AsVal_int(argv[2], NULL);
23026  _v = SWIG_CheckState(res);
23027  }
23028  if (_v) {
23029  return _wrap_istream_ignore__SWIG_0(self, args);
23030  }
23031  }
23032  }
23033  }
23034 
23035 fail:
23036  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'istream_ignore'.\n"
23037  " Possible C/C++ prototypes are:\n"
23038  " std::basic_istream< char >::ignore(std::streamsize,std::basic_istream< char >::int_type)\n"
23039  " std::basic_istream< char >::ignore(std::streamsize)\n"
23040  " std::basic_istream< char >::ignore()\n");
23041  return 0;
23042 }
23043 
23044 
23045 SWIGINTERN PyObject *_wrap_istream_peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23046  PyObject *resultobj = 0;
23047  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
23048  void *argp1 = 0 ;
23049  int res1 = 0 ;
23050  PyObject * obj0 = 0 ;
23051  std::basic_istream< char >::int_type result;
23052 
23053  if (!PyArg_ParseTuple(args,(char *)"O:istream_peek",&obj0)) SWIG_fail;
23054  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23055  if (!SWIG_IsOK(res1)) {
23056  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_peek" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
23057  }
23058  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
23059  result = (std::basic_istream< char >::int_type)(arg1)->peek();
23060  resultobj = SWIG_From_int(static_cast< int >(result));
23061  return resultobj;
23062 fail:
23063  return NULL;
23064 }
23065 
23066 
23067 SWIGINTERN PyObject *_wrap_istream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23068  PyObject *resultobj = 0;
23069  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
23070  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
23071  std::streamsize arg3 ;
23072  void *argp1 = 0 ;
23073  int res1 = 0 ;
23074  int res2 ;
23075  char *buf2 = 0 ;
23076  int alloc2 = 0 ;
23077  size_t val3 ;
23078  int ecode3 = 0 ;
23079  PyObject * obj0 = 0 ;
23080  PyObject * obj1 = 0 ;
23081  PyObject * obj2 = 0 ;
23082  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
23083 
23084  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_read",&obj0,&obj1,&obj2)) SWIG_fail;
23085  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23086  if (!SWIG_IsOK(res1)) {
23087  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_read" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
23088  }
23089  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
23090  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23091  if (!SWIG_IsOK(res2)) {
23092  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_read" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
23093  }
23094  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
23095  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
23096  if (!SWIG_IsOK(ecode3)) {
23097  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_read" "', argument " "3"" of type '" "std::streamsize""'");
23098  }
23099  arg3 = static_cast< std::streamsize >(val3);
23100  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->read(arg2,arg3);
23101  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23102  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23103  return resultobj;
23104 fail:
23105  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23106  return NULL;
23107 }
23108 
23109 
23110 SWIGINTERN PyObject *_wrap_istream_readsome(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23111  PyObject *resultobj = 0;
23112  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
23113  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
23114  std::streamsize arg3 ;
23115  void *argp1 = 0 ;
23116  int res1 = 0 ;
23117  int res2 ;
23118  char *buf2 = 0 ;
23119  int alloc2 = 0 ;
23120  size_t val3 ;
23121  int ecode3 = 0 ;
23122  PyObject * obj0 = 0 ;
23123  PyObject * obj1 = 0 ;
23124  PyObject * obj2 = 0 ;
23125  std::streamsize result;
23126 
23127  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_readsome",&obj0,&obj1,&obj2)) SWIG_fail;
23128  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23129  if (!SWIG_IsOK(res1)) {
23130  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_readsome" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
23131  }
23132  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
23133  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23134  if (!SWIG_IsOK(res2)) {
23135  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_readsome" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
23136  }
23137  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
23138  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
23139  if (!SWIG_IsOK(ecode3)) {
23140  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_readsome" "', argument " "3"" of type '" "std::streamsize""'");
23141  }
23142  arg3 = static_cast< std::streamsize >(val3);
23143  result = (arg1)->readsome(arg2,arg3);
23144  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
23145  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23146  return resultobj;
23147 fail:
23148  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23149  return NULL;
23150 }
23151 
23152 
23153 SWIGINTERN PyObject *_wrap_istream_putback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23154  PyObject *resultobj = 0;
23155  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
23156  std::basic_istream< char >::char_type arg2 ;
23157  void *argp1 = 0 ;
23158  int res1 = 0 ;
23159  char val2 ;
23160  int ecode2 = 0 ;
23161  PyObject * obj0 = 0 ;
23162  PyObject * obj1 = 0 ;
23163  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
23164 
23165  if (!PyArg_ParseTuple(args,(char *)"OO:istream_putback",&obj0,&obj1)) SWIG_fail;
23166  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23167  if (!SWIG_IsOK(res1)) {
23168  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_putback" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
23169  }
23170  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
23171  ecode2 = SWIG_AsVal_char(obj1, &val2);
23172  if (!SWIG_IsOK(ecode2)) {
23173  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "istream_putback" "', argument " "2"" of type '" "std::basic_istream< char >::char_type""'");
23174  }
23175  arg2 = static_cast< std::basic_istream< char >::char_type >(val2);
23176  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->putback(arg2);
23177  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23178  return resultobj;
23179 fail:
23180  return NULL;
23181 }
23182 
23183 
23184 SWIGINTERN PyObject *_wrap_istream_unget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23185  PyObject *resultobj = 0;
23186  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
23187  void *argp1 = 0 ;
23188  int res1 = 0 ;
23189  PyObject * obj0 = 0 ;
23190  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
23191 
23192  if (!PyArg_ParseTuple(args,(char *)"O:istream_unget",&obj0)) SWIG_fail;
23193  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23194  if (!SWIG_IsOK(res1)) {
23195  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_unget" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
23196  }
23197  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
23198  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->unget();
23199  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23200  return resultobj;
23201 fail:
23202  return NULL;
23203 }
23204 
23205 
23206 SWIGINTERN PyObject *_wrap_istream_sync(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23207  PyObject *resultobj = 0;
23208  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
23209  void *argp1 = 0 ;
23210  int res1 = 0 ;
23211  PyObject * obj0 = 0 ;
23212  int result;
23213 
23214  if (!PyArg_ParseTuple(args,(char *)"O:istream_sync",&obj0)) SWIG_fail;
23215  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23216  if (!SWIG_IsOK(res1)) {
23217  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_sync" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
23218  }
23219  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
23220  result = (int)(arg1)->sync();
23221  resultobj = SWIG_From_int(static_cast< int >(result));
23222  return resultobj;
23223 fail:
23224  return NULL;
23225 }
23226 
23227 
23228 SWIGINTERN PyObject *_wrap_istream_tellg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23229  PyObject *resultobj = 0;
23230  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
23231  void *argp1 = 0 ;
23232  int res1 = 0 ;
23233  PyObject * obj0 = 0 ;
23234  std::basic_istream< char >::pos_type result;
23235 
23236  if (!PyArg_ParseTuple(args,(char *)"O:istream_tellg",&obj0)) SWIG_fail;
23237  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23238  if (!SWIG_IsOK(res1)) {
23239  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_tellg" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
23240  }
23241  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
23242  result = (arg1)->tellg();
23243  resultobj = SWIG_NewPointerObj((new std::basic_istream< char >::pos_type(static_cast< const std::basic_istream< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN | 0 );
23244  return resultobj;
23245 fail:
23246  return NULL;
23247 }
23248 
23249 
23250 SWIGINTERN PyObject *_wrap_istream_seekg__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23251  PyObject *resultobj = 0;
23252  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
23253  std::basic_istream< char >::pos_type arg2 ;
23254  void *argp1 = 0 ;
23255  int res1 = 0 ;
23256  void *argp2 ;
23257  int res2 = 0 ;
23258  PyObject * obj0 = 0 ;
23259  PyObject * obj1 = 0 ;
23260  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
23261 
23262  if (!PyArg_ParseTuple(args,(char *)"OO:istream_seekg",&obj0,&obj1)) SWIG_fail;
23263  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23264  if (!SWIG_IsOK(res1)) {
23265  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_seekg" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
23266  }
23267  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
23268  {
23269  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streampos, 0 | 0);
23270  if (!SWIG_IsOK(res2)) {
23271  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_seekg" "', argument " "2"" of type '" "std::basic_istream< char >::pos_type""'");
23272  }
23273  if (!argp2) {
23274  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream_seekg" "', argument " "2"" of type '" "std::basic_istream< char >::pos_type""'");
23275  } else {
23276  std::basic_istream< char >::pos_type * temp = reinterpret_cast< std::basic_istream< char >::pos_type * >(argp2);
23277  arg2 = *temp;
23278  if (SWIG_IsNewObj(res2)) delete temp;
23279  }
23280  }
23281  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->seekg(arg2);
23282  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23283  return resultobj;
23284 fail:
23285  return NULL;
23286 }
23287 
23288 
23289 SWIGINTERN PyObject *_wrap_istream_seekg__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23290  PyObject *resultobj = 0;
23291  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
23292  std::basic_istream< char >::off_type arg2 ;
23293  std::ios_base::seekdir arg3 ;
23294  void *argp1 = 0 ;
23295  int res1 = 0 ;
23296  void *argp2 ;
23297  int res2 = 0 ;
23298  int val3 ;
23299  int ecode3 = 0 ;
23300  PyObject * obj0 = 0 ;
23301  PyObject * obj1 = 0 ;
23302  PyObject * obj2 = 0 ;
23303  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
23304 
23305  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_seekg",&obj0,&obj1,&obj2)) SWIG_fail;
23306  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23307  if (!SWIG_IsOK(res1)) {
23308  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_seekg" "', argument " "1"" of type '" "std::basic_istream< char > *""'");
23309  }
23310  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
23311  {
23312  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streamoff, 0 | 0);
23313  if (!SWIG_IsOK(res2)) {
23314  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_seekg" "', argument " "2"" of type '" "std::basic_istream< char >::off_type""'");
23315  }
23316  if (!argp2) {
23317  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream_seekg" "', argument " "2"" of type '" "std::basic_istream< char >::off_type""'");
23318  } else {
23319  std::basic_istream< char >::off_type * temp = reinterpret_cast< std::basic_istream< char >::off_type * >(argp2);
23320  arg2 = *temp;
23321  if (SWIG_IsNewObj(res2)) delete temp;
23322  }
23323  }
23324  ecode3 = SWIG_AsVal_int(obj2, &val3);
23325  if (!SWIG_IsOK(ecode3)) {
23326  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_seekg" "', argument " "3"" of type '" "std::ios_base::seekdir""'");
23327  }
23328  arg3 = static_cast< std::ios_base::seekdir >(val3);
23329  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->seekg(arg2,arg3);
23330  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23331  return resultobj;
23332 fail:
23333  return NULL;
23334 }
23335 
23336 
23337 SWIGINTERN PyObject *_wrap_istream_seekg(PyObject *self, PyObject *args) {
23338  Py_ssize_t argc;
23339  PyObject *argv[4] = {
23340  0
23341  };
23342  Py_ssize_t ii;
23343 
23344  if (!PyTuple_Check(args)) SWIG_fail;
23345  argc = args ? PyObject_Length(args) : 0;
23346  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
23347  argv[ii] = PyTuple_GET_ITEM(args,ii);
23348  }
23349  if (argc == 2) {
23350  int _v;
23351  void *vptr = 0;
23352  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
23353  _v = SWIG_CheckState(res);
23354  if (_v) {
23355  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streampos, 0);
23356  _v = SWIG_CheckState(res);
23357  if (_v) {
23358  return _wrap_istream_seekg__SWIG_0(self, args);
23359  }
23360  }
23361  }
23362  if (argc == 3) {
23363  int _v;
23364  void *vptr = 0;
23365  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
23366  _v = SWIG_CheckState(res);
23367  if (_v) {
23368  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streamoff, 0);
23369  _v = SWIG_CheckState(res);
23370  if (_v) {
23371  {
23372  int res = SWIG_AsVal_int(argv[2], NULL);
23373  _v = SWIG_CheckState(res);
23374  }
23375  if (_v) {
23376  return _wrap_istream_seekg__SWIG_1(self, args);
23377  }
23378  }
23379  }
23380  }
23381 
23382 fail:
23383  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'istream_seekg'.\n"
23384  " Possible C/C++ prototypes are:\n"
23385  " std::basic_istream< char >::seekg(std::basic_istream< char >::pos_type)\n"
23386  " std::basic_istream< char >::seekg(std::basic_istream< char >::off_type,std::ios_base::seekdir)\n");
23387  return 0;
23388 }
23389 
23390 
23391 SWIGINTERN PyObject *istream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23392  PyObject *obj;
23393  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
23394  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
23395  return SWIG_Py_Void();
23396 }
23397 
23398 SWIGINTERN PyObject *_wrap_new_iostream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23399  PyObject *resultobj = 0;
23400  std::basic_streambuf< char,std::char_traits< char > > *arg1 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
23401  void *argp1 = 0 ;
23402  int res1 = 0 ;
23403  PyObject * obj0 = 0 ;
23404  std::basic_iostream< char > *result = 0 ;
23405 
23406  if (!PyArg_ParseTuple(args,(char *)"O:new_iostream",&obj0)) SWIG_fail;
23407  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
23408  if (!SWIG_IsOK(res1)) {
23409  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_iostream" "', argument " "1"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'");
23410  }
23411  arg1 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp1);
23412  result = (std::basic_iostream< char > *)new std::basic_iostream< char >(arg1);
23413  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NEW | 0 );
23414  return resultobj;
23415 fail:
23416  return NULL;
23417 }
23418 
23419 
23420 SWIGINTERN PyObject *_wrap_delete_iostream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23421  PyObject *resultobj = 0;
23422  std::basic_iostream< char > *arg1 = (std::basic_iostream< char > *) 0 ;
23423  void *argp1 = 0 ;
23424  int res1 = 0 ;
23425  PyObject * obj0 = 0 ;
23426 
23427  if (!PyArg_ParseTuple(args,(char *)"O:delete_iostream",&obj0)) SWIG_fail;
23428  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN | 0 );
23429  if (!SWIG_IsOK(res1)) {
23430  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_iostream" "', argument " "1"" of type '" "std::basic_iostream< char > *""'");
23431  }
23432  arg1 = reinterpret_cast< std::basic_iostream< char > * >(argp1);
23433  delete arg1;
23434  resultobj = SWIG_Py_Void();
23435  return resultobj;
23436 fail:
23437  return NULL;
23438 }
23439 
23440 
23441 SWIGINTERN PyObject *iostream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442  PyObject *obj;
23443  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
23444  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
23445  return SWIG_Py_Void();
23446 }
23447 
23448 SWIGINTERN PyObject *endl_cb_ptr_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23449  PyObject *module;
23450  PyObject *d;
23451  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
23452  d = PyModule_GetDict(module);
23453  if (!d) return NULL;
23454 
23455  return SWIG_Py_Void();
23456 }
23457 
23458 
23459 SWIGINTERN PyObject *_wrap_endl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23460  PyObject *resultobj = 0;
23461  std::basic_ostream< char,std::char_traits< char > > *arg1 = 0 ;
23462  void *argp1 = 0 ;
23463  int res1 = 0 ;
23464  PyObject * obj0 = 0 ;
23465  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
23466 
23467  if (!PyArg_ParseTuple(args,(char *)"O:endl",&obj0)) SWIG_fail;
23468  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
23469  if (!SWIG_IsOK(res1)) {
23470  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "endl" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'");
23471  }
23472  if (!argp1) {
23473  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "endl" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'");
23474  }
23475  arg1 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp1);
23476  result = (std::basic_ostream< char,std::char_traits< char > > *) &std::SWIGTEMPLATEDISAMBIGUATOR endl< char,std::char_traits< char > >(*arg1);
23477  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23478  return resultobj;
23479 fail:
23480  return NULL;
23481 }
23482 
23483 
23484 SWIGINTERN PyObject *ends_cb_ptr_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23485  PyObject *module;
23486  PyObject *d;
23487  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
23488  d = PyModule_GetDict(module);
23489  if (!d) return NULL;
23490 
23491  return SWIG_Py_Void();
23492 }
23493 
23494 
23495 SWIGINTERN PyObject *_wrap_ends(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23496  PyObject *resultobj = 0;
23497  std::basic_ostream< char,std::char_traits< char > > *arg1 = 0 ;
23498  void *argp1 = 0 ;
23499  int res1 = 0 ;
23500  PyObject * obj0 = 0 ;
23501  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
23502 
23503  if (!PyArg_ParseTuple(args,(char *)"O:ends",&obj0)) SWIG_fail;
23504  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
23505  if (!SWIG_IsOK(res1)) {
23506  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ends" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'");
23507  }
23508  if (!argp1) {
23509  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ends" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'");
23510  }
23511  arg1 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp1);
23512  result = (std::basic_ostream< char,std::char_traits< char > > *) &std::SWIGTEMPLATEDISAMBIGUATOR ends< char,std::char_traits< char > >(*arg1);
23513  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23514  return resultobj;
23515 fail:
23516  return NULL;
23517 }
23518 
23519 
23520 SWIGINTERN PyObject *flush_cb_ptr_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23521  PyObject *module;
23522  PyObject *d;
23523  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
23524  d = PyModule_GetDict(module);
23525  if (!d) return NULL;
23526 
23527  return SWIG_Py_Void();
23528 }
23529 
23530 
23531 SWIGINTERN PyObject *_wrap_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23532  PyObject *resultobj = 0;
23533  std::basic_ostream< char,std::char_traits< char > > *arg1 = 0 ;
23534  void *argp1 = 0 ;
23535  int res1 = 0 ;
23536  PyObject * obj0 = 0 ;
23537  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
23538 
23539  if (!PyArg_ParseTuple(args,(char *)"O:flush",&obj0)) SWIG_fail;
23540  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
23541  if (!SWIG_IsOK(res1)) {
23542  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "flush" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'");
23543  }
23544  if (!argp1) {
23545  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "flush" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'");
23546  }
23547  arg1 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp1);
23548  result = (std::basic_ostream< char,std::char_traits< char > > *) &std::SWIGTEMPLATEDISAMBIGUATOR flush< char,std::char_traits< char > >(*arg1);
23549  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 | 0 );
23550  return resultobj;
23551 fail:
23552  return NULL;
23553 }
23554 
23555 
23556 SWIGINTERN PyObject *_wrap_delete_streambuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23557  PyObject *resultobj = 0;
23558  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
23559  void *argp1 = 0 ;
23560  int res1 = 0 ;
23561  PyObject * obj0 = 0 ;
23562 
23563  if (!PyArg_ParseTuple(args,(char *)"O:delete_streambuf",&obj0)) SWIG_fail;
23564  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN | 0 );
23565  if (!SWIG_IsOK(res1)) {
23566  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_streambuf" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
23567  }
23568  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
23569  delete arg1;
23570  resultobj = SWIG_Py_Void();
23571  return resultobj;
23572 fail:
23573  return NULL;
23574 }
23575 
23576 
23577 SWIGINTERN PyObject *_wrap_streambuf_pubimbue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23578  PyObject *resultobj = 0;
23579  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
23580  std::locale *arg2 = 0 ;
23581  void *argp1 = 0 ;
23582  int res1 = 0 ;
23583  void *argp2 = 0 ;
23584  int res2 = 0 ;
23585  PyObject * obj0 = 0 ;
23586  PyObject * obj1 = 0 ;
23587  std::locale result;
23588 
23589  if (!PyArg_ParseTuple(args,(char *)"OO:streambuf_pubimbue",&obj0,&obj1)) SWIG_fail;
23590  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
23591  if (!SWIG_IsOK(res1)) {
23592  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubimbue" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
23593  }
23594  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
23595  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__locale, 0 | 0);
23596  if (!SWIG_IsOK(res2)) {
23597  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubimbue" "', argument " "2"" of type '" "std::locale const &""'");
23598  }
23599  if (!argp2) {
23600  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streambuf_pubimbue" "', argument " "2"" of type '" "std::locale const &""'");
23601  }
23602  arg2 = reinterpret_cast< std::locale * >(argp2);
23603  result = (arg1)->pubimbue((std::locale const &)*arg2);
23604  resultobj = SWIG_NewPointerObj((new std::locale(static_cast< const std::locale& >(result))), SWIGTYPE_p_std__locale, SWIG_POINTER_OWN | 0 );
23605  return resultobj;
23606 fail:
23607  return NULL;
23608 }
23609 
23610 
23611 SWIGINTERN PyObject *_wrap_streambuf_getloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23612  PyObject *resultobj = 0;
23613  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
23614  void *argp1 = 0 ;
23615  int res1 = 0 ;
23616  PyObject * obj0 = 0 ;
23617  std::locale result;
23618 
23619  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_getloc",&obj0)) SWIG_fail;
23620  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
23621  if (!SWIG_IsOK(res1)) {
23622  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_getloc" "', argument " "1"" of type '" "std::basic_streambuf< char > const *""'");
23623  }
23624  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
23625  result = ((std::basic_streambuf< char > const *)arg1)->getloc();
23626  resultobj = SWIG_NewPointerObj((new std::locale(static_cast< const std::locale& >(result))), SWIGTYPE_p_std__locale, SWIG_POINTER_OWN | 0 );
23627  return resultobj;
23628 fail:
23629  return NULL;
23630 }
23631 
23632 
23633 SWIGINTERN PyObject *_wrap_streambuf_pubsetbuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23634  PyObject *resultobj = 0;
23635  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
23636  std::basic_streambuf< char >::char_type *arg2 = (std::basic_streambuf< char >::char_type *) 0 ;
23637  std::streamsize arg3 ;
23638  void *argp1 = 0 ;
23639  int res1 = 0 ;
23640  int res2 ;
23641  char *buf2 = 0 ;
23642  int alloc2 = 0 ;
23643  size_t val3 ;
23644  int ecode3 = 0 ;
23645  PyObject * obj0 = 0 ;
23646  PyObject * obj1 = 0 ;
23647  PyObject * obj2 = 0 ;
23648  std::basic_streambuf< char,std::char_traits< char > > *result = 0 ;
23649 
23650  if (!PyArg_ParseTuple(args,(char *)"OOO:streambuf_pubsetbuf",&obj0,&obj1,&obj2)) SWIG_fail;
23651  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
23652  if (!SWIG_IsOK(res1)) {
23653  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubsetbuf" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
23654  }
23655  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
23656  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23657  if (!SWIG_IsOK(res2)) {
23658  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubsetbuf" "', argument " "2"" of type '" "std::basic_streambuf< char >::char_type *""'");
23659  }
23660  arg2 = reinterpret_cast< std::basic_streambuf< char >::char_type * >(buf2);
23661  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
23662  if (!SWIG_IsOK(ecode3)) {
23663  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_pubsetbuf" "', argument " "3"" of type '" "std::streamsize""'");
23664  }
23665  arg3 = static_cast< std::streamsize >(val3);
23666  result = (std::basic_streambuf< char,std::char_traits< char > > *)(arg1)->pubsetbuf(arg2,arg3);
23667  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
23668  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23669  return resultobj;
23670 fail:
23671  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23672  return NULL;
23673 }
23674 
23675 
23676 SWIGINTERN PyObject *_wrap_streambuf_pubseekoff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23677  PyObject *resultobj = 0;
23678  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
23679  std::basic_streambuf< char >::off_type arg2 ;
23680  std::ios_base::seekdir arg3 ;
23681  std::ios_base::openmode arg4 ;
23682  void *argp1 = 0 ;
23683  int res1 = 0 ;
23684  void *argp2 ;
23685  int res2 = 0 ;
23686  int val3 ;
23687  int ecode3 = 0 ;
23688  int val4 ;
23689  int ecode4 = 0 ;
23690  PyObject * obj0 = 0 ;
23691  PyObject * obj1 = 0 ;
23692  PyObject * obj2 = 0 ;
23693  PyObject * obj3 = 0 ;
23694  std::basic_streambuf< char >::pos_type result;
23695 
23696  if (!PyArg_ParseTuple(args,(char *)"OOOO:streambuf_pubseekoff",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23697  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
23698  if (!SWIG_IsOK(res1)) {
23699  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubseekoff" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
23700  }
23701  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
23702  {
23703  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streamoff, 0 | 0);
23704  if (!SWIG_IsOK(res2)) {
23705  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubseekoff" "', argument " "2"" of type '" "std::basic_streambuf< char >::off_type""'");
23706  }
23707  if (!argp2) {
23708  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streambuf_pubseekoff" "', argument " "2"" of type '" "std::basic_streambuf< char >::off_type""'");
23709  } else {
23710  std::basic_streambuf< char >::off_type * temp = reinterpret_cast< std::basic_streambuf< char >::off_type * >(argp2);
23711  arg2 = *temp;
23712  if (SWIG_IsNewObj(res2)) delete temp;
23713  }
23714  }
23715  ecode3 = SWIG_AsVal_int(obj2, &val3);
23716  if (!SWIG_IsOK(ecode3)) {
23717  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_pubseekoff" "', argument " "3"" of type '" "std::ios_base::seekdir""'");
23718  }
23719  arg3 = static_cast< std::ios_base::seekdir >(val3);
23720  ecode4 = SWIG_AsVal_int(obj3, &val4);
23721  if (!SWIG_IsOK(ecode4)) {
23722  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "streambuf_pubseekoff" "', argument " "4"" of type '" "std::ios_base::openmode""'");
23723  }
23724  arg4 = static_cast< std::ios_base::openmode >(val4);
23725  result = (arg1)->pubseekoff(arg2,arg3,arg4);
23726  resultobj = SWIG_NewPointerObj((new std::basic_streambuf< char >::pos_type(static_cast< const std::basic_streambuf< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN | 0 );
23727  return resultobj;
23728 fail:
23729  return NULL;
23730 }
23731 
23732 
23733 SWIGINTERN PyObject *_wrap_streambuf_pubseekoff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23734  PyObject *resultobj = 0;
23735  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
23736  std::basic_streambuf< char >::off_type arg2 ;
23737  std::ios_base::seekdir arg3 ;
23738  void *argp1 = 0 ;
23739  int res1 = 0 ;
23740  void *argp2 ;
23741  int res2 = 0 ;
23742  int val3 ;
23743  int ecode3 = 0 ;
23744  PyObject * obj0 = 0 ;
23745  PyObject * obj1 = 0 ;
23746  PyObject * obj2 = 0 ;
23747  std::basic_streambuf< char >::pos_type result;
23748 
23749  if (!PyArg_ParseTuple(args,(char *)"OOO:streambuf_pubseekoff",&obj0,&obj1,&obj2)) SWIG_fail;
23750  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
23751  if (!SWIG_IsOK(res1)) {
23752  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubseekoff" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
23753  }
23754  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
23755  {
23756  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streamoff, 0 | 0);
23757  if (!SWIG_IsOK(res2)) {
23758  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubseekoff" "', argument " "2"" of type '" "std::basic_streambuf< char >::off_type""'");
23759  }
23760  if (!argp2) {
23761  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streambuf_pubseekoff" "', argument " "2"" of type '" "std::basic_streambuf< char >::off_type""'");
23762  } else {
23763  std::basic_streambuf< char >::off_type * temp = reinterpret_cast< std::basic_streambuf< char >::off_type * >(argp2);
23764  arg2 = *temp;
23765  if (SWIG_IsNewObj(res2)) delete temp;
23766  }
23767  }
23768  ecode3 = SWIG_AsVal_int(obj2, &val3);
23769  if (!SWIG_IsOK(ecode3)) {
23770  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_pubseekoff" "', argument " "3"" of type '" "std::ios_base::seekdir""'");
23771  }
23772  arg3 = static_cast< std::ios_base::seekdir >(val3);
23773  result = (arg1)->pubseekoff(arg2,arg3);
23774  resultobj = SWIG_NewPointerObj((new std::basic_streambuf< char >::pos_type(static_cast< const std::basic_streambuf< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN | 0 );
23775  return resultobj;
23776 fail:
23777  return NULL;
23778 }
23779 
23780 
23781 SWIGINTERN PyObject *_wrap_streambuf_pubseekoff(PyObject *self, PyObject *args) {
23782  Py_ssize_t argc;
23783  PyObject *argv[5] = {
23784  0
23785  };
23786  Py_ssize_t ii;
23787 
23788  if (!PyTuple_Check(args)) SWIG_fail;
23789  argc = args ? PyObject_Length(args) : 0;
23790  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
23791  argv[ii] = PyTuple_GET_ITEM(args,ii);
23792  }
23793  if (argc == 3) {
23794  int _v;
23795  void *vptr = 0;
23796  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
23797  _v = SWIG_CheckState(res);
23798  if (_v) {
23799  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streamoff, 0);
23800  _v = SWIG_CheckState(res);
23801  if (_v) {
23802  {
23803  int res = SWIG_AsVal_int(argv[2], NULL);
23804  _v = SWIG_CheckState(res);
23805  }
23806  if (_v) {
23807  return _wrap_streambuf_pubseekoff__SWIG_1(self, args);
23808  }
23809  }
23810  }
23811  }
23812  if (argc == 4) {
23813  int _v;
23814  void *vptr = 0;
23815  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
23816  _v = SWIG_CheckState(res);
23817  if (_v) {
23818  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streamoff, 0);
23819  _v = SWIG_CheckState(res);
23820  if (_v) {
23821  {
23822  int res = SWIG_AsVal_int(argv[2], NULL);
23823  _v = SWIG_CheckState(res);
23824  }
23825  if (_v) {
23826  {
23827  int res = SWIG_AsVal_int(argv[3], NULL);
23828  _v = SWIG_CheckState(res);
23829  }
23830  if (_v) {
23831  return _wrap_streambuf_pubseekoff__SWIG_0(self, args);
23832  }
23833  }
23834  }
23835  }
23836  }
23837 
23838 fail:
23839  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'streambuf_pubseekoff'.\n"
23840  " Possible C/C++ prototypes are:\n"
23841  " std::basic_streambuf< char >::pubseekoff(std::basic_streambuf< char >::off_type,std::ios_base::seekdir,std::ios_base::openmode)\n"
23842  " std::basic_streambuf< char >::pubseekoff(std::basic_streambuf< char >::off_type,std::ios_base::seekdir)\n");
23843  return 0;
23844 }
23845 
23846 
23847 SWIGINTERN PyObject *_wrap_streambuf_pubseekpos__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23848  PyObject *resultobj = 0;
23849  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
23850  std::basic_streambuf< char >::pos_type arg2 ;
23851  std::ios_base::openmode arg3 ;
23852  void *argp1 = 0 ;
23853  int res1 = 0 ;
23854  void *argp2 ;
23855  int res2 = 0 ;
23856  int val3 ;
23857  int ecode3 = 0 ;
23858  PyObject * obj0 = 0 ;
23859  PyObject * obj1 = 0 ;
23860  PyObject * obj2 = 0 ;
23861  std::basic_streambuf< char >::pos_type result;
23862 
23863  if (!PyArg_ParseTuple(args,(char *)"OOO:streambuf_pubseekpos",&obj0,&obj1,&obj2)) SWIG_fail;
23864  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
23865  if (!SWIG_IsOK(res1)) {
23866  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubseekpos" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
23867  }
23868  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
23869  {
23870  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streampos, 0 | 0);
23871  if (!SWIG_IsOK(res2)) {
23872  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubseekpos" "', argument " "2"" of type '" "std::basic_streambuf< char >::pos_type""'");
23873  }
23874  if (!argp2) {
23875  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streambuf_pubseekpos" "', argument " "2"" of type '" "std::basic_streambuf< char >::pos_type""'");
23876  } else {
23877  std::basic_streambuf< char >::pos_type * temp = reinterpret_cast< std::basic_streambuf< char >::pos_type * >(argp2);
23878  arg2 = *temp;
23879  if (SWIG_IsNewObj(res2)) delete temp;
23880  }
23881  }
23882  ecode3 = SWIG_AsVal_int(obj2, &val3);
23883  if (!SWIG_IsOK(ecode3)) {
23884  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_pubseekpos" "', argument " "3"" of type '" "std::ios_base::openmode""'");
23885  }
23886  arg3 = static_cast< std::ios_base::openmode >(val3);
23887  result = (arg1)->pubseekpos(arg2,arg3);
23888  resultobj = SWIG_NewPointerObj((new std::basic_streambuf< char >::pos_type(static_cast< const std::basic_streambuf< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN | 0 );
23889  return resultobj;
23890 fail:
23891  return NULL;
23892 }
23893 
23894 
23895 SWIGINTERN PyObject *_wrap_streambuf_pubseekpos__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23896  PyObject *resultobj = 0;
23897  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
23898  std::basic_streambuf< char >::pos_type arg2 ;
23899  void *argp1 = 0 ;
23900  int res1 = 0 ;
23901  void *argp2 ;
23902  int res2 = 0 ;
23903  PyObject * obj0 = 0 ;
23904  PyObject * obj1 = 0 ;
23905  std::basic_streambuf< char >::pos_type result;
23906 
23907  if (!PyArg_ParseTuple(args,(char *)"OO:streambuf_pubseekpos",&obj0,&obj1)) SWIG_fail;
23908  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
23909  if (!SWIG_IsOK(res1)) {
23910  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubseekpos" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
23911  }
23912  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
23913  {
23914  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streampos, 0 | 0);
23915  if (!SWIG_IsOK(res2)) {
23916  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubseekpos" "', argument " "2"" of type '" "std::basic_streambuf< char >::pos_type""'");
23917  }
23918  if (!argp2) {
23919  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streambuf_pubseekpos" "', argument " "2"" of type '" "std::basic_streambuf< char >::pos_type""'");
23920  } else {
23921  std::basic_streambuf< char >::pos_type * temp = reinterpret_cast< std::basic_streambuf< char >::pos_type * >(argp2);
23922  arg2 = *temp;
23923  if (SWIG_IsNewObj(res2)) delete temp;
23924  }
23925  }
23926  result = (arg1)->pubseekpos(arg2);
23927  resultobj = SWIG_NewPointerObj((new std::basic_streambuf< char >::pos_type(static_cast< const std::basic_streambuf< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN | 0 );
23928  return resultobj;
23929 fail:
23930  return NULL;
23931 }
23932 
23933 
23934 SWIGINTERN PyObject *_wrap_streambuf_pubseekpos(PyObject *self, PyObject *args) {
23935  Py_ssize_t argc;
23936  PyObject *argv[4] = {
23937  0
23938  };
23939  Py_ssize_t ii;
23940 
23941  if (!PyTuple_Check(args)) SWIG_fail;
23942  argc = args ? PyObject_Length(args) : 0;
23943  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
23944  argv[ii] = PyTuple_GET_ITEM(args,ii);
23945  }
23946  if (argc == 2) {
23947  int _v;
23948  void *vptr = 0;
23949  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
23950  _v = SWIG_CheckState(res);
23951  if (_v) {
23952  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streampos, 0);
23953  _v = SWIG_CheckState(res);
23954  if (_v) {
23955  return _wrap_streambuf_pubseekpos__SWIG_1(self, args);
23956  }
23957  }
23958  }
23959  if (argc == 3) {
23960  int _v;
23961  void *vptr = 0;
23962  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
23963  _v = SWIG_CheckState(res);
23964  if (_v) {
23965  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streampos, 0);
23966  _v = SWIG_CheckState(res);
23967  if (_v) {
23968  {
23969  int res = SWIG_AsVal_int(argv[2], NULL);
23970  _v = SWIG_CheckState(res);
23971  }
23972  if (_v) {
23973  return _wrap_streambuf_pubseekpos__SWIG_0(self, args);
23974  }
23975  }
23976  }
23977  }
23978 
23979 fail:
23980  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'streambuf_pubseekpos'.\n"
23981  " Possible C/C++ prototypes are:\n"
23982  " std::basic_streambuf< char >::pubseekpos(std::basic_streambuf< char >::pos_type,std::ios_base::openmode)\n"
23983  " std::basic_streambuf< char >::pubseekpos(std::basic_streambuf< char >::pos_type)\n");
23984  return 0;
23985 }
23986 
23987 
23988 SWIGINTERN PyObject *_wrap_streambuf_pubsync(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23989  PyObject *resultobj = 0;
23990  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
23991  void *argp1 = 0 ;
23992  int res1 = 0 ;
23993  PyObject * obj0 = 0 ;
23994  int result;
23995 
23996  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_pubsync",&obj0)) SWIG_fail;
23997  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
23998  if (!SWIG_IsOK(res1)) {
23999  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubsync" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
24000  }
24001  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
24002  result = (int)(arg1)->pubsync();
24003  resultobj = SWIG_From_int(static_cast< int >(result));
24004  return resultobj;
24005 fail:
24006  return NULL;
24007 }
24008 
24009 
24010 SWIGINTERN PyObject *_wrap_streambuf_in_avail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24011  PyObject *resultobj = 0;
24012  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
24013  void *argp1 = 0 ;
24014  int res1 = 0 ;
24015  PyObject * obj0 = 0 ;
24016  std::streamsize result;
24017 
24018  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_in_avail",&obj0)) SWIG_fail;
24019  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
24020  if (!SWIG_IsOK(res1)) {
24021  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_in_avail" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
24022  }
24023  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
24024  result = (arg1)->in_avail();
24025  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
24026  return resultobj;
24027 fail:
24028  return NULL;
24029 }
24030 
24031 
24032 SWIGINTERN PyObject *_wrap_streambuf_snextc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24033  PyObject *resultobj = 0;
24034  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
24035  void *argp1 = 0 ;
24036  int res1 = 0 ;
24037  PyObject * obj0 = 0 ;
24038  std::basic_streambuf< char >::int_type result;
24039 
24040  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_snextc",&obj0)) SWIG_fail;
24041  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
24042  if (!SWIG_IsOK(res1)) {
24043  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_snextc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
24044  }
24045  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
24046  result = (std::basic_streambuf< char >::int_type)(arg1)->snextc();
24047  resultobj = SWIG_From_int(static_cast< int >(result));
24048  return resultobj;
24049 fail:
24050  return NULL;
24051 }
24052 
24053 
24054 SWIGINTERN PyObject *_wrap_streambuf_sbumpc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24055  PyObject *resultobj = 0;
24056  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
24057  void *argp1 = 0 ;
24058  int res1 = 0 ;
24059  PyObject * obj0 = 0 ;
24060  std::basic_streambuf< char >::int_type result;
24061 
24062  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_sbumpc",&obj0)) SWIG_fail;
24063  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
24064  if (!SWIG_IsOK(res1)) {
24065  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sbumpc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
24066  }
24067  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
24068  result = (std::basic_streambuf< char >::int_type)(arg1)->sbumpc();
24069  resultobj = SWIG_From_int(static_cast< int >(result));
24070  return resultobj;
24071 fail:
24072  return NULL;
24073 }
24074 
24075 
24076 SWIGINTERN PyObject *_wrap_streambuf_sgetc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24077  PyObject *resultobj = 0;
24078  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
24079  void *argp1 = 0 ;
24080  int res1 = 0 ;
24081  PyObject * obj0 = 0 ;
24082  std::basic_streambuf< char >::int_type result;
24083 
24084  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_sgetc",&obj0)) SWIG_fail;
24085  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
24086  if (!SWIG_IsOK(res1)) {
24087  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sgetc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
24088  }
24089  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
24090  result = (std::basic_streambuf< char >::int_type)(arg1)->sgetc();
24091  resultobj = SWIG_From_int(static_cast< int >(result));
24092  return resultobj;
24093 fail:
24094  return NULL;
24095 }
24096 
24097 
24098 SWIGINTERN PyObject *_wrap_streambuf_sgetn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24099  PyObject *resultobj = 0;
24100  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
24101  std::basic_streambuf< char >::char_type *arg2 = (std::basic_streambuf< char >::char_type *) 0 ;
24102  std::streamsize arg3 ;
24103  void *argp1 = 0 ;
24104  int res1 = 0 ;
24105  int res2 ;
24106  char *buf2 = 0 ;
24107  int alloc2 = 0 ;
24108  size_t val3 ;
24109  int ecode3 = 0 ;
24110  PyObject * obj0 = 0 ;
24111  PyObject * obj1 = 0 ;
24112  PyObject * obj2 = 0 ;
24113  std::streamsize result;
24114 
24115  if (!PyArg_ParseTuple(args,(char *)"OOO:streambuf_sgetn",&obj0,&obj1,&obj2)) SWIG_fail;
24116  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
24117  if (!SWIG_IsOK(res1)) {
24118  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sgetn" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
24119  }
24120  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
24121  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24122  if (!SWIG_IsOK(res2)) {
24123  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_sgetn" "', argument " "2"" of type '" "std::basic_streambuf< char >::char_type *""'");
24124  }
24125  arg2 = reinterpret_cast< std::basic_streambuf< char >::char_type * >(buf2);
24126  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
24127  if (!SWIG_IsOK(ecode3)) {
24128  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_sgetn" "', argument " "3"" of type '" "std::streamsize""'");
24129  }
24130  arg3 = static_cast< std::streamsize >(val3);
24131  result = (arg1)->sgetn(arg2,arg3);
24132  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
24133  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24134  return resultobj;
24135 fail:
24136  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24137  return NULL;
24138 }
24139 
24140 
24141 SWIGINTERN PyObject *_wrap_streambuf_sputbackc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24142  PyObject *resultobj = 0;
24143  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
24144  std::basic_streambuf< char >::char_type arg2 ;
24145  void *argp1 = 0 ;
24146  int res1 = 0 ;
24147  char val2 ;
24148  int ecode2 = 0 ;
24149  PyObject * obj0 = 0 ;
24150  PyObject * obj1 = 0 ;
24151  std::basic_streambuf< char >::int_type result;
24152 
24153  if (!PyArg_ParseTuple(args,(char *)"OO:streambuf_sputbackc",&obj0,&obj1)) SWIG_fail;
24154  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
24155  if (!SWIG_IsOK(res1)) {
24156  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sputbackc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
24157  }
24158  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
24159  ecode2 = SWIG_AsVal_char(obj1, &val2);
24160  if (!SWIG_IsOK(ecode2)) {
24161  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streambuf_sputbackc" "', argument " "2"" of type '" "std::basic_streambuf< char >::char_type""'");
24162  }
24163  arg2 = static_cast< std::basic_streambuf< char >::char_type >(val2);
24164  result = (std::basic_streambuf< char >::int_type)(arg1)->sputbackc(arg2);
24165  resultobj = SWIG_From_int(static_cast< int >(result));
24166  return resultobj;
24167 fail:
24168  return NULL;
24169 }
24170 
24171 
24172 SWIGINTERN PyObject *_wrap_streambuf_sungetc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173  PyObject *resultobj = 0;
24174  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
24175  void *argp1 = 0 ;
24176  int res1 = 0 ;
24177  PyObject * obj0 = 0 ;
24178  std::basic_streambuf< char >::int_type result;
24179 
24180  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_sungetc",&obj0)) SWIG_fail;
24181  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
24182  if (!SWIG_IsOK(res1)) {
24183  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sungetc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
24184  }
24185  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
24186  result = (std::basic_streambuf< char >::int_type)(arg1)->sungetc();
24187  resultobj = SWIG_From_int(static_cast< int >(result));
24188  return resultobj;
24189 fail:
24190  return NULL;
24191 }
24192 
24193 
24194 SWIGINTERN PyObject *_wrap_streambuf_sputc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24195  PyObject *resultobj = 0;
24196  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
24197  std::basic_streambuf< char >::char_type arg2 ;
24198  void *argp1 = 0 ;
24199  int res1 = 0 ;
24200  char val2 ;
24201  int ecode2 = 0 ;
24202  PyObject * obj0 = 0 ;
24203  PyObject * obj1 = 0 ;
24204  std::basic_streambuf< char >::int_type result;
24205 
24206  if (!PyArg_ParseTuple(args,(char *)"OO:streambuf_sputc",&obj0,&obj1)) SWIG_fail;
24207  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
24208  if (!SWIG_IsOK(res1)) {
24209  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sputc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
24210  }
24211  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
24212  ecode2 = SWIG_AsVal_char(obj1, &val2);
24213  if (!SWIG_IsOK(ecode2)) {
24214  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streambuf_sputc" "', argument " "2"" of type '" "std::basic_streambuf< char >::char_type""'");
24215  }
24216  arg2 = static_cast< std::basic_streambuf< char >::char_type >(val2);
24217  result = (std::basic_streambuf< char >::int_type)(arg1)->sputc(arg2);
24218  resultobj = SWIG_From_int(static_cast< int >(result));
24219  return resultobj;
24220 fail:
24221  return NULL;
24222 }
24223 
24224 
24225 SWIGINTERN PyObject *_wrap_streambuf_sputn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24226  PyObject *resultobj = 0;
24227  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
24228  std::basic_streambuf< char >::char_type *arg2 = (std::basic_streambuf< char >::char_type *) 0 ;
24229  std::streamsize arg3 ;
24230  void *argp1 = 0 ;
24231  int res1 = 0 ;
24232  int res2 ;
24233  char *buf2 = 0 ;
24234  int alloc2 = 0 ;
24235  size_t val3 ;
24236  int ecode3 = 0 ;
24237  PyObject * obj0 = 0 ;
24238  PyObject * obj1 = 0 ;
24239  PyObject * obj2 = 0 ;
24240  std::streamsize result;
24241 
24242  if (!PyArg_ParseTuple(args,(char *)"OOO:streambuf_sputn",&obj0,&obj1,&obj2)) SWIG_fail;
24243  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 | 0 );
24244  if (!SWIG_IsOK(res1)) {
24245  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sputn" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'");
24246  }
24247  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
24248  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24249  if (!SWIG_IsOK(res2)) {
24250  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_sputn" "', argument " "2"" of type '" "std::basic_streambuf< char >::char_type const *""'");
24251  }
24252  arg2 = reinterpret_cast< std::basic_streambuf< char >::char_type * >(buf2);
24253  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
24254  if (!SWIG_IsOK(ecode3)) {
24255  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_sputn" "', argument " "3"" of type '" "std::streamsize""'");
24256  }
24257  arg3 = static_cast< std::streamsize >(val3);
24258  result = (arg1)->sputn((std::basic_streambuf< char >::char_type const *)arg2,arg3);
24259  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
24260  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24261  return resultobj;
24262 fail:
24263  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24264  return NULL;
24265 }
24266 
24267 
24268 SWIGINTERN PyObject *streambuf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24269  PyObject *obj;
24270  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
24271  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
24272  return SWIG_Py_Void();
24273 }
24274 
24275 SWIGINTERN PyObject *_wrap_new_istringstream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24276  PyObject *resultobj = 0;
24277  std::ios_base::openmode arg1 ;
24278  int val1 ;
24279  int ecode1 = 0 ;
24280  PyObject * obj0 = 0 ;
24281  std::basic_istringstream< char > *result = 0 ;
24282 
24283  if (!PyArg_ParseTuple(args,(char *)"O:new_istringstream",&obj0)) SWIG_fail;
24284  ecode1 = SWIG_AsVal_int(obj0, &val1);
24285  if (!SWIG_IsOK(ecode1)) {
24286  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_istringstream" "', argument " "1"" of type '" "std::ios_base::openmode""'");
24287  }
24288  arg1 = static_cast< std::ios_base::openmode >(val1);
24289  result = (std::basic_istringstream< char > *)new std::basic_istringstream< char >(arg1);
24290  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24291  return resultobj;
24292 fail:
24293  return NULL;
24294 }
24295 
24296 
24297 SWIGINTERN PyObject *_wrap_new_istringstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24298  PyObject *resultobj = 0;
24299  std::basic_istringstream< char > *result = 0 ;
24300 
24301  if (!PyArg_ParseTuple(args,(char *)":new_istringstream")) SWIG_fail;
24302  result = (std::basic_istringstream< char > *)new std::basic_istringstream< char >();
24303  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24304  return resultobj;
24305 fail:
24306  return NULL;
24307 }
24308 
24309 
24310 SWIGINTERN PyObject *_wrap_new_istringstream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24311  PyObject *resultobj = 0;
24312  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
24313  std::ios_base::openmode arg2 ;
24314  void *argp1 = 0 ;
24315  int res1 = 0 ;
24316  int val2 ;
24317  int ecode2 = 0 ;
24318  PyObject * obj0 = 0 ;
24319  PyObject * obj1 = 0 ;
24320  std::basic_istringstream< char > *result = 0 ;
24321 
24322  if (!PyArg_ParseTuple(args,(char *)"OO:new_istringstream",&obj0,&obj1)) SWIG_fail;
24323  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0);
24324  if (!SWIG_IsOK(res1)) {
24325  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_istringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24326  }
24327  if (!argp1) {
24328  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_istringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24329  }
24330  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
24331  ecode2 = SWIG_AsVal_int(obj1, &val2);
24332  if (!SWIG_IsOK(ecode2)) {
24333  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_istringstream" "', argument " "2"" of type '" "std::ios_base::openmode""'");
24334  }
24335  arg2 = static_cast< std::ios_base::openmode >(val2);
24336  result = (std::basic_istringstream< char > *)new std::basic_istringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1,arg2);
24337  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24338  return resultobj;
24339 fail:
24340  return NULL;
24341 }
24342 
24343 
24344 SWIGINTERN PyObject *_wrap_new_istringstream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24345  PyObject *resultobj = 0;
24346  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
24347  void *argp1 = 0 ;
24348  int res1 = 0 ;
24349  PyObject * obj0 = 0 ;
24350  std::basic_istringstream< char > *result = 0 ;
24351 
24352  if (!PyArg_ParseTuple(args,(char *)"O:new_istringstream",&obj0)) SWIG_fail;
24353  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0);
24354  if (!SWIG_IsOK(res1)) {
24355  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_istringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24356  }
24357  if (!argp1) {
24358  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_istringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24359  }
24360  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
24361  result = (std::basic_istringstream< char > *)new std::basic_istringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
24362  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24363  return resultobj;
24364 fail:
24365  return NULL;
24366 }
24367 
24368 
24369 SWIGINTERN PyObject *_wrap_new_istringstream(PyObject *self, PyObject *args) {
24370  Py_ssize_t argc;
24371  PyObject *argv[3] = {
24372  0
24373  };
24374  Py_ssize_t ii;
24375 
24376  if (!PyTuple_Check(args)) SWIG_fail;
24377  argc = args ? PyObject_Length(args) : 0;
24378  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
24379  argv[ii] = PyTuple_GET_ITEM(args,ii);
24380  }
24381  if (argc == 0) {
24382  return _wrap_new_istringstream__SWIG_1(self, args);
24383  }
24384  if (argc == 1) {
24385  int _v;
24386  int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
24387  _v = SWIG_CheckState(res);
24388  if (_v) {
24389  return _wrap_new_istringstream__SWIG_3(self, args);
24390  }
24391  }
24392  if (argc == 1) {
24393  int _v;
24394  {
24395  int res = SWIG_AsVal_int(argv[0], NULL);
24396  _v = SWIG_CheckState(res);
24397  }
24398  if (_v) {
24399  return _wrap_new_istringstream__SWIG_0(self, args);
24400  }
24401  }
24402  if (argc == 2) {
24403  int _v;
24404  int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
24405  _v = SWIG_CheckState(res);
24406  if (_v) {
24407  {
24408  int res = SWIG_AsVal_int(argv[1], NULL);
24409  _v = SWIG_CheckState(res);
24410  }
24411  if (_v) {
24412  return _wrap_new_istringstream__SWIG_2(self, args);
24413  }
24414  }
24415  }
24416 
24417 fail:
24418  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_istringstream'.\n"
24419  " Possible C/C++ prototypes are:\n"
24420  " std::basic_istringstream< char >::basic_istringstream(std::ios_base::openmode)\n"
24421  " std::basic_istringstream< char >::basic_istringstream()\n"
24422  " std::basic_istringstream< char >::basic_istringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &,std::ios_base::openmode)\n"
24423  " std::basic_istringstream< char >::basic_istringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
24424  return 0;
24425 }
24426 
24427 
24428 SWIGINTERN PyObject *_wrap_delete_istringstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24429  PyObject *resultobj = 0;
24430  std::basic_istringstream< char > *arg1 = (std::basic_istringstream< char > *) 0 ;
24431  void *argp1 = 0 ;
24432  int res1 = 0 ;
24433  PyObject * obj0 = 0 ;
24434 
24435  if (!PyArg_ParseTuple(args,(char *)"O:delete_istringstream",&obj0)) SWIG_fail;
24436  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_DISOWN | 0 );
24437  if (!SWIG_IsOK(res1)) {
24438  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_istringstream" "', argument " "1"" of type '" "std::basic_istringstream< char > *""'");
24439  }
24440  arg1 = reinterpret_cast< std::basic_istringstream< char > * >(argp1);
24441  delete arg1;
24442  resultobj = SWIG_Py_Void();
24443  return resultobj;
24444 fail:
24445  return NULL;
24446 }
24447 
24448 
24449 SWIGINTERN PyObject *_wrap_istringstream_rdbuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24450  PyObject *resultobj = 0;
24451  std::basic_istringstream< char > *arg1 = (std::basic_istringstream< char > *) 0 ;
24452  void *argp1 = 0 ;
24453  int res1 = 0 ;
24454  PyObject * obj0 = 0 ;
24455  std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;
24456 
24457  if (!PyArg_ParseTuple(args,(char *)"O:istringstream_rdbuf",&obj0)) SWIG_fail;
24458  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
24459  if (!SWIG_IsOK(res1)) {
24460  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istringstream_rdbuf" "', argument " "1"" of type '" "std::basic_istringstream< char > const *""'");
24461  }
24462  arg1 = reinterpret_cast< std::basic_istringstream< char > * >(argp1);
24463  result = (std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *)((std::basic_istringstream< char > const *)arg1)->rdbuf();
24464  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
24465  return resultobj;
24466 fail:
24467  return NULL;
24468 }
24469 
24470 
24471 SWIGINTERN PyObject *_wrap_istringstream_str__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24472  PyObject *resultobj = 0;
24473  std::basic_istringstream< char > *arg1 = (std::basic_istringstream< char > *) 0 ;
24474  void *argp1 = 0 ;
24475  int res1 = 0 ;
24476  PyObject * obj0 = 0 ;
24477  basic_string< char,std::char_traits< char >,std::allocator< char > > result;
24478 
24479  if (!PyArg_ParseTuple(args,(char *)"O:istringstream_str",&obj0)) SWIG_fail;
24480  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
24481  if (!SWIG_IsOK(res1)) {
24482  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istringstream_str" "', argument " "1"" of type '" "std::basic_istringstream< char > const *""'");
24483  }
24484  arg1 = reinterpret_cast< std::basic_istringstream< char > * >(argp1);
24485  result = ((std::basic_istringstream< char > const *)arg1)->str();
24486  resultobj = SWIG_NewPointerObj((new basic_string< char,std::char_traits< char >,std::allocator< char > >(static_cast< const basic_string< char,std::char_traits< char >,std::allocator< char > >& >(result))), SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN | 0 );
24487  return resultobj;
24488 fail:
24489  return NULL;
24490 }
24491 
24492 
24493 SWIGINTERN PyObject *_wrap_istringstream_str__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24494  PyObject *resultobj = 0;
24495  std::basic_istringstream< char > *arg1 = (std::basic_istringstream< char > *) 0 ;
24496  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg2 = 0 ;
24497  void *argp1 = 0 ;
24498  int res1 = 0 ;
24499  void *argp2 = 0 ;
24500  int res2 = 0 ;
24501  PyObject * obj0 = 0 ;
24502  PyObject * obj1 = 0 ;
24503 
24504  if (!PyArg_ParseTuple(args,(char *)"OO:istringstream_str",&obj0,&obj1)) SWIG_fail;
24505  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
24506  if (!SWIG_IsOK(res1)) {
24507  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istringstream_str" "', argument " "1"" of type '" "std::basic_istringstream< char > *""'");
24508  }
24509  arg1 = reinterpret_cast< std::basic_istringstream< char > * >(argp1);
24510  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0);
24511  if (!SWIG_IsOK(res2)) {
24512  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istringstream_str" "', argument " "2"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24513  }
24514  if (!argp2) {
24515  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istringstream_str" "', argument " "2"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24516  }
24517  arg2 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp2);
24518  (arg1)->str((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg2);
24519  resultobj = SWIG_Py_Void();
24520  return resultobj;
24521 fail:
24522  return NULL;
24523 }
24524 
24525 
24526 SWIGINTERN PyObject *_wrap_istringstream_str(PyObject *self, PyObject *args) {
24527  Py_ssize_t argc;
24528  PyObject *argv[3] = {
24529  0
24530  };
24531  Py_ssize_t ii;
24532 
24533  if (!PyTuple_Check(args)) SWIG_fail;
24534  argc = args ? PyObject_Length(args) : 0;
24535  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
24536  argv[ii] = PyTuple_GET_ITEM(args,ii);
24537  }
24538  if (argc == 1) {
24539  int _v;
24540  void *vptr = 0;
24541  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
24542  _v = SWIG_CheckState(res);
24543  if (_v) {
24544  return _wrap_istringstream_str__SWIG_0(self, args);
24545  }
24546  }
24547  if (argc == 2) {
24548  int _v;
24549  void *vptr = 0;
24550  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
24551  _v = SWIG_CheckState(res);
24552  if (_v) {
24553  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
24554  _v = SWIG_CheckState(res);
24555  if (_v) {
24556  return _wrap_istringstream_str__SWIG_1(self, args);
24557  }
24558  }
24559  }
24560 
24561 fail:
24562  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'istringstream_str'.\n"
24563  " Possible C/C++ prototypes are:\n"
24564  " std::basic_istringstream< char >::str() const\n"
24565  " std::basic_istringstream< char >::str(basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
24566  return 0;
24567 }
24568 
24569 
24570 SWIGINTERN PyObject *istringstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24571  PyObject *obj;
24572  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
24573  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_NewClientData(obj));
24574  return SWIG_Py_Void();
24575 }
24576 
24577 SWIGINTERN PyObject *_wrap_new_ostringstream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24578  PyObject *resultobj = 0;
24579  std::ios_base::openmode arg1 ;
24580  int val1 ;
24581  int ecode1 = 0 ;
24582  PyObject * obj0 = 0 ;
24583  std::basic_ostringstream< char > *result = 0 ;
24584 
24585  if (!PyArg_ParseTuple(args,(char *)"O:new_ostringstream",&obj0)) SWIG_fail;
24586  ecode1 = SWIG_AsVal_int(obj0, &val1);
24587  if (!SWIG_IsOK(ecode1)) {
24588  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ostringstream" "', argument " "1"" of type '" "std::ios_base::openmode""'");
24589  }
24590  arg1 = static_cast< std::ios_base::openmode >(val1);
24591  result = (std::basic_ostringstream< char > *)new std::basic_ostringstream< char >(arg1);
24592  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24593  return resultobj;
24594 fail:
24595  return NULL;
24596 }
24597 
24598 
24599 SWIGINTERN PyObject *_wrap_new_ostringstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600  PyObject *resultobj = 0;
24601  std::basic_ostringstream< char > *result = 0 ;
24602 
24603  if (!PyArg_ParseTuple(args,(char *)":new_ostringstream")) SWIG_fail;
24604  result = (std::basic_ostringstream< char > *)new std::basic_ostringstream< char >();
24605  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24606  return resultobj;
24607 fail:
24608  return NULL;
24609 }
24610 
24611 
24612 SWIGINTERN PyObject *_wrap_new_ostringstream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24613  PyObject *resultobj = 0;
24614  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
24615  std::ios_base::openmode arg2 ;
24616  void *argp1 = 0 ;
24617  int res1 = 0 ;
24618  int val2 ;
24619  int ecode2 = 0 ;
24620  PyObject * obj0 = 0 ;
24621  PyObject * obj1 = 0 ;
24622  std::basic_ostringstream< char > *result = 0 ;
24623 
24624  if (!PyArg_ParseTuple(args,(char *)"OO:new_ostringstream",&obj0,&obj1)) SWIG_fail;
24625  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0);
24626  if (!SWIG_IsOK(res1)) {
24627  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ostringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24628  }
24629  if (!argp1) {
24630  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ostringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24631  }
24632  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
24633  ecode2 = SWIG_AsVal_int(obj1, &val2);
24634  if (!SWIG_IsOK(ecode2)) {
24635  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ostringstream" "', argument " "2"" of type '" "std::ios_base::openmode""'");
24636  }
24637  arg2 = static_cast< std::ios_base::openmode >(val2);
24638  result = (std::basic_ostringstream< char > *)new std::basic_ostringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1,arg2);
24639  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24640  return resultobj;
24641 fail:
24642  return NULL;
24643 }
24644 
24645 
24646 SWIGINTERN PyObject *_wrap_new_ostringstream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24647  PyObject *resultobj = 0;
24648  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
24649  void *argp1 = 0 ;
24650  int res1 = 0 ;
24651  PyObject * obj0 = 0 ;
24652  std::basic_ostringstream< char > *result = 0 ;
24653 
24654  if (!PyArg_ParseTuple(args,(char *)"O:new_ostringstream",&obj0)) SWIG_fail;
24655  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0);
24656  if (!SWIG_IsOK(res1)) {
24657  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ostringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24658  }
24659  if (!argp1) {
24660  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ostringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24661  }
24662  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
24663  result = (std::basic_ostringstream< char > *)new std::basic_ostringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
24664  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24665  return resultobj;
24666 fail:
24667  return NULL;
24668 }
24669 
24670 
24671 SWIGINTERN PyObject *_wrap_new_ostringstream(PyObject *self, PyObject *args) {
24672  Py_ssize_t argc;
24673  PyObject *argv[3] = {
24674  0
24675  };
24676  Py_ssize_t ii;
24677 
24678  if (!PyTuple_Check(args)) SWIG_fail;
24679  argc = args ? PyObject_Length(args) : 0;
24680  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
24681  argv[ii] = PyTuple_GET_ITEM(args,ii);
24682  }
24683  if (argc == 0) {
24684  return _wrap_new_ostringstream__SWIG_1(self, args);
24685  }
24686  if (argc == 1) {
24687  int _v;
24688  int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
24689  _v = SWIG_CheckState(res);
24690  if (_v) {
24691  return _wrap_new_ostringstream__SWIG_3(self, args);
24692  }
24693  }
24694  if (argc == 1) {
24695  int _v;
24696  {
24697  int res = SWIG_AsVal_int(argv[0], NULL);
24698  _v = SWIG_CheckState(res);
24699  }
24700  if (_v) {
24701  return _wrap_new_ostringstream__SWIG_0(self, args);
24702  }
24703  }
24704  if (argc == 2) {
24705  int _v;
24706  int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
24707  _v = SWIG_CheckState(res);
24708  if (_v) {
24709  {
24710  int res = SWIG_AsVal_int(argv[1], NULL);
24711  _v = SWIG_CheckState(res);
24712  }
24713  if (_v) {
24714  return _wrap_new_ostringstream__SWIG_2(self, args);
24715  }
24716  }
24717  }
24718 
24719 fail:
24720  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ostringstream'.\n"
24721  " Possible C/C++ prototypes are:\n"
24722  " std::basic_ostringstream< char >::basic_ostringstream(std::ios_base::openmode)\n"
24723  " std::basic_ostringstream< char >::basic_ostringstream()\n"
24724  " std::basic_ostringstream< char >::basic_ostringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &,std::ios_base::openmode)\n"
24725  " std::basic_ostringstream< char >::basic_ostringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
24726  return 0;
24727 }
24728 
24729 
24730 SWIGINTERN PyObject *_wrap_delete_ostringstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24731  PyObject *resultobj = 0;
24732  std::basic_ostringstream< char > *arg1 = (std::basic_ostringstream< char > *) 0 ;
24733  void *argp1 = 0 ;
24734  int res1 = 0 ;
24735  PyObject * obj0 = 0 ;
24736 
24737  if (!PyArg_ParseTuple(args,(char *)"O:delete_ostringstream",&obj0)) SWIG_fail;
24738  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_DISOWN | 0 );
24739  if (!SWIG_IsOK(res1)) {
24740  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ostringstream" "', argument " "1"" of type '" "std::basic_ostringstream< char > *""'");
24741  }
24742  arg1 = reinterpret_cast< std::basic_ostringstream< char > * >(argp1);
24743  delete arg1;
24744  resultobj = SWIG_Py_Void();
24745  return resultobj;
24746 fail:
24747  return NULL;
24748 }
24749 
24750 
24751 SWIGINTERN PyObject *_wrap_ostringstream_rdbuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24752  PyObject *resultobj = 0;
24753  std::basic_ostringstream< char > *arg1 = (std::basic_ostringstream< char > *) 0 ;
24754  void *argp1 = 0 ;
24755  int res1 = 0 ;
24756  PyObject * obj0 = 0 ;
24757  std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;
24758 
24759  if (!PyArg_ParseTuple(args,(char *)"O:ostringstream_rdbuf",&obj0)) SWIG_fail;
24760  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
24761  if (!SWIG_IsOK(res1)) {
24762  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostringstream_rdbuf" "', argument " "1"" of type '" "std::basic_ostringstream< char > const *""'");
24763  }
24764  arg1 = reinterpret_cast< std::basic_ostringstream< char > * >(argp1);
24765  result = (std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *)((std::basic_ostringstream< char > const *)arg1)->rdbuf();
24766  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
24767  return resultobj;
24768 fail:
24769  return NULL;
24770 }
24771 
24772 
24773 SWIGINTERN PyObject *_wrap_ostringstream_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24774  PyObject *resultobj = 0;
24775  std::basic_ostringstream< char > *arg1 = (std::basic_ostringstream< char > *) 0 ;
24776  void *argp1 = 0 ;
24777  int res1 = 0 ;
24778  PyObject * obj0 = 0 ;
24779  basic_string< char,std::char_traits< char >,std::allocator< char > > result;
24780 
24781  if (!PyArg_ParseTuple(args,(char *)"O:ostringstream_str",&obj0)) SWIG_fail;
24782  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
24783  if (!SWIG_IsOK(res1)) {
24784  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostringstream_str" "', argument " "1"" of type '" "std::basic_ostringstream< char > const *""'");
24785  }
24786  arg1 = reinterpret_cast< std::basic_ostringstream< char > * >(argp1);
24787  result = ((std::basic_ostringstream< char > const *)arg1)->str();
24788  resultobj = SWIG_NewPointerObj((new basic_string< char,std::char_traits< char >,std::allocator< char > >(static_cast< const basic_string< char,std::char_traits< char >,std::allocator< char > >& >(result))), SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN | 0 );
24789  return resultobj;
24790 fail:
24791  return NULL;
24792 }
24793 
24794 
24795 SWIGINTERN PyObject *ostringstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24796  PyObject *obj;
24797  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
24798  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_NewClientData(obj));
24799  return SWIG_Py_Void();
24800 }
24801 
24802 SWIGINTERN PyObject *_wrap_new_stringstream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24803  PyObject *resultobj = 0;
24804  std::ios_base::openmode arg1 ;
24805  int val1 ;
24806  int ecode1 = 0 ;
24807  PyObject * obj0 = 0 ;
24808  std::basic_stringstream< char > *result = 0 ;
24809 
24810  if (!PyArg_ParseTuple(args,(char *)"O:new_stringstream",&obj0)) SWIG_fail;
24811  ecode1 = SWIG_AsVal_int(obj0, &val1);
24812  if (!SWIG_IsOK(ecode1)) {
24813  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_stringstream" "', argument " "1"" of type '" "std::ios_base::openmode""'");
24814  }
24815  arg1 = static_cast< std::ios_base::openmode >(val1);
24816  result = (std::basic_stringstream< char > *)new std::basic_stringstream< char >(arg1);
24817  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24818  return resultobj;
24819 fail:
24820  return NULL;
24821 }
24822 
24823 
24824 SWIGINTERN PyObject *_wrap_new_stringstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24825  PyObject *resultobj = 0;
24826  std::basic_stringstream< char > *result = 0 ;
24827 
24828  if (!PyArg_ParseTuple(args,(char *)":new_stringstream")) SWIG_fail;
24829  result = (std::basic_stringstream< char > *)new std::basic_stringstream< char >();
24830  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24831  return resultobj;
24832 fail:
24833  return NULL;
24834 }
24835 
24836 
24837 SWIGINTERN PyObject *_wrap_new_stringstream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24838  PyObject *resultobj = 0;
24839  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
24840  std::ios_base::openmode arg2 ;
24841  void *argp1 = 0 ;
24842  int res1 = 0 ;
24843  int val2 ;
24844  int ecode2 = 0 ;
24845  PyObject * obj0 = 0 ;
24846  PyObject * obj1 = 0 ;
24847  std::basic_stringstream< char > *result = 0 ;
24848 
24849  if (!PyArg_ParseTuple(args,(char *)"OO:new_stringstream",&obj0,&obj1)) SWIG_fail;
24850  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0);
24851  if (!SWIG_IsOK(res1)) {
24852  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_stringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24853  }
24854  if (!argp1) {
24855  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_stringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24856  }
24857  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
24858  ecode2 = SWIG_AsVal_int(obj1, &val2);
24859  if (!SWIG_IsOK(ecode2)) {
24860  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_stringstream" "', argument " "2"" of type '" "std::ios_base::openmode""'");
24861  }
24862  arg2 = static_cast< std::ios_base::openmode >(val2);
24863  result = (std::basic_stringstream< char > *)new std::basic_stringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1,arg2);
24864  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24865  return resultobj;
24866 fail:
24867  return NULL;
24868 }
24869 
24870 
24871 SWIGINTERN PyObject *_wrap_new_stringstream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24872  PyObject *resultobj = 0;
24873  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
24874  void *argp1 = 0 ;
24875  int res1 = 0 ;
24876  PyObject * obj0 = 0 ;
24877  std::basic_stringstream< char > *result = 0 ;
24878 
24879  if (!PyArg_ParseTuple(args,(char *)"O:new_stringstream",&obj0)) SWIG_fail;
24880  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0);
24881  if (!SWIG_IsOK(res1)) {
24882  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_stringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24883  }
24884  if (!argp1) {
24885  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_stringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
24886  }
24887  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
24888  result = (std::basic_stringstream< char > *)new std::basic_stringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
24889  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 );
24890  return resultobj;
24891 fail:
24892  return NULL;
24893 }
24894 
24895 
24896 SWIGINTERN PyObject *_wrap_new_stringstream(PyObject *self, PyObject *args) {
24897  Py_ssize_t argc;
24898  PyObject *argv[3] = {
24899  0
24900  };
24901  Py_ssize_t ii;
24902 
24903  if (!PyTuple_Check(args)) SWIG_fail;
24904  argc = args ? PyObject_Length(args) : 0;
24905  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
24906  argv[ii] = PyTuple_GET_ITEM(args,ii);
24907  }
24908  if (argc == 0) {
24909  return _wrap_new_stringstream__SWIG_1(self, args);
24910  }
24911  if (argc == 1) {
24912  int _v;
24913  int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
24914  _v = SWIG_CheckState(res);
24915  if (_v) {
24916  return _wrap_new_stringstream__SWIG_3(self, args);
24917  }
24918  }
24919  if (argc == 1) {
24920  int _v;
24921  {
24922  int res = SWIG_AsVal_int(argv[0], NULL);
24923  _v = SWIG_CheckState(res);
24924  }
24925  if (_v) {
24926  return _wrap_new_stringstream__SWIG_0(self, args);
24927  }
24928  }
24929  if (argc == 2) {
24930  int _v;
24931  int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
24932  _v = SWIG_CheckState(res);
24933  if (_v) {
24934  {
24935  int res = SWIG_AsVal_int(argv[1], NULL);
24936  _v = SWIG_CheckState(res);
24937  }
24938  if (_v) {
24939  return _wrap_new_stringstream__SWIG_2(self, args);
24940  }
24941  }
24942  }
24943 
24944 fail:
24945  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_stringstream'.\n"
24946  " Possible C/C++ prototypes are:\n"
24947  " std::basic_stringstream< char >::basic_stringstream(std::ios_base::openmode)\n"
24948  " std::basic_stringstream< char >::basic_stringstream()\n"
24949  " std::basic_stringstream< char >::basic_stringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &,std::ios_base::openmode)\n"
24950  " std::basic_stringstream< char >::basic_stringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
24951  return 0;
24952 }
24953 
24954 
24955 SWIGINTERN PyObject *_wrap_delete_stringstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24956  PyObject *resultobj = 0;
24957  std::basic_stringstream< char > *arg1 = (std::basic_stringstream< char > *) 0 ;
24958  void *argp1 = 0 ;
24959  int res1 = 0 ;
24960  PyObject * obj0 = 0 ;
24961 
24962  if (!PyArg_ParseTuple(args,(char *)"O:delete_stringstream",&obj0)) SWIG_fail;
24963  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_DISOWN | 0 );
24964  if (!SWIG_IsOK(res1)) {
24965  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_stringstream" "', argument " "1"" of type '" "std::basic_stringstream< char > *""'");
24966  }
24967  arg1 = reinterpret_cast< std::basic_stringstream< char > * >(argp1);
24968  delete arg1;
24969  resultobj = SWIG_Py_Void();
24970  return resultobj;
24971 fail:
24972  return NULL;
24973 }
24974 
24975 
24976 SWIGINTERN PyObject *_wrap_stringstream_rdbuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24977  PyObject *resultobj = 0;
24978  std::basic_stringstream< char > *arg1 = (std::basic_stringstream< char > *) 0 ;
24979  void *argp1 = 0 ;
24980  int res1 = 0 ;
24981  PyObject * obj0 = 0 ;
24982  std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;
24983 
24984  if (!PyArg_ParseTuple(args,(char *)"O:stringstream_rdbuf",&obj0)) SWIG_fail;
24985  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
24986  if (!SWIG_IsOK(res1)) {
24987  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringstream_rdbuf" "', argument " "1"" of type '" "std::basic_stringstream< char > const *""'");
24988  }
24989  arg1 = reinterpret_cast< std::basic_stringstream< char > * >(argp1);
24990  result = (std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *)((std::basic_stringstream< char > const *)arg1)->rdbuf();
24991  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
24992  return resultobj;
24993 fail:
24994  return NULL;
24995 }
24996 
24997 
24998 SWIGINTERN PyObject *_wrap_stringstream_str__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24999  PyObject *resultobj = 0;
25000  std::basic_stringstream< char > *arg1 = (std::basic_stringstream< char > *) 0 ;
25001  void *argp1 = 0 ;
25002  int res1 = 0 ;
25003  PyObject * obj0 = 0 ;
25004  basic_string< char,std::char_traits< char >,std::allocator< char > > result;
25005 
25006  if (!PyArg_ParseTuple(args,(char *)"O:stringstream_str",&obj0)) SWIG_fail;
25007  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
25008  if (!SWIG_IsOK(res1)) {
25009  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringstream_str" "', argument " "1"" of type '" "std::basic_stringstream< char > const *""'");
25010  }
25011  arg1 = reinterpret_cast< std::basic_stringstream< char > * >(argp1);
25012  result = ((std::basic_stringstream< char > const *)arg1)->str();
25013  resultobj = SWIG_NewPointerObj((new basic_string< char,std::char_traits< char >,std::allocator< char > >(static_cast< const basic_string< char,std::char_traits< char >,std::allocator< char > >& >(result))), SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN | 0 );
25014  return resultobj;
25015 fail:
25016  return NULL;
25017 }
25018 
25019 
25020 SWIGINTERN PyObject *_wrap_stringstream_str__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25021  PyObject *resultobj = 0;
25022  std::basic_stringstream< char > *arg1 = (std::basic_stringstream< char > *) 0 ;
25023  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg2 = 0 ;
25024  void *argp1 = 0 ;
25025  int res1 = 0 ;
25026  void *argp2 = 0 ;
25027  int res2 = 0 ;
25028  PyObject * obj0 = 0 ;
25029  PyObject * obj1 = 0 ;
25030 
25031  if (!PyArg_ParseTuple(args,(char *)"OO:stringstream_str",&obj0,&obj1)) SWIG_fail;
25032  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0 );
25033  if (!SWIG_IsOK(res1)) {
25034  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringstream_str" "', argument " "1"" of type '" "std::basic_stringstream< char > *""'");
25035  }
25036  arg1 = reinterpret_cast< std::basic_stringstream< char > * >(argp1);
25037  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 | 0);
25038  if (!SWIG_IsOK(res2)) {
25039  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "stringstream_str" "', argument " "2"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
25040  }
25041  if (!argp2) {
25042  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "stringstream_str" "', argument " "2"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
25043  }
25044  arg2 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp2);
25045  (arg1)->str((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg2);
25046  resultobj = SWIG_Py_Void();
25047  return resultobj;
25048 fail:
25049  return NULL;
25050 }
25051 
25052 
25053 SWIGINTERN PyObject *_wrap_stringstream_str(PyObject *self, PyObject *args) {
25054  Py_ssize_t argc;
25055  PyObject *argv[3] = {
25056  0
25057  };
25058  Py_ssize_t ii;
25059 
25060  if (!PyTuple_Check(args)) SWIG_fail;
25061  argc = args ? PyObject_Length(args) : 0;
25062  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
25063  argv[ii] = PyTuple_GET_ITEM(args,ii);
25064  }
25065  if (argc == 1) {
25066  int _v;
25067  void *vptr = 0;
25068  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
25069  _v = SWIG_CheckState(res);
25070  if (_v) {
25071  return _wrap_stringstream_str__SWIG_0(self, args);
25072  }
25073  }
25074  if (argc == 2) {
25075  int _v;
25076  void *vptr = 0;
25077  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
25078  _v = SWIG_CheckState(res);
25079  if (_v) {
25080  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
25081  _v = SWIG_CheckState(res);
25082  if (_v) {
25083  return _wrap_stringstream_str__SWIG_1(self, args);
25084  }
25085  }
25086  }
25087 
25088 fail:
25089  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'stringstream_str'.\n"
25090  " Possible C/C++ prototypes are:\n"
25091  " std::basic_stringstream< char >::str() const\n"
25092  " std::basic_stringstream< char >::str(basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
25093  return 0;
25094 }
25095 
25096 
25097 SWIGINTERN PyObject *stringstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25098  PyObject *obj;
25099  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
25100  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_NewClientData(obj));
25101  return SWIG_Py_Void();
25102 }
25103 
25104 SWIGINTERN PyObject *_wrap_new_PairIntInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25105  PyObject *resultobj = 0;
25106  std::pair< int,int > *result = 0 ;
25107 
25108  if (!PyArg_ParseTuple(args,(char *)":new_PairIntInt")) SWIG_fail;
25109  result = (std::pair< int,int > *)new std::pair< int,int >();
25110  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_int_t, SWIG_POINTER_NEW | 0 );
25111  return resultobj;
25112 fail:
25113  return NULL;
25114 }
25115 
25116 
25117 SWIGINTERN PyObject *_wrap_new_PairIntInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25118  PyObject *resultobj = 0;
25119  int arg1 ;
25120  int arg2 ;
25121  int val1 ;
25122  int ecode1 = 0 ;
25123  int val2 ;
25124  int ecode2 = 0 ;
25125  PyObject * obj0 = 0 ;
25126  PyObject * obj1 = 0 ;
25127  std::pair< int,int > *result = 0 ;
25128 
25129  if (!PyArg_ParseTuple(args,(char *)"OO:new_PairIntInt",&obj0,&obj1)) SWIG_fail;
25130  ecode1 = SWIG_AsVal_int(obj0, &val1);
25131  if (!SWIG_IsOK(ecode1)) {
25132  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PairIntInt" "', argument " "1"" of type '" "int""'");
25133  }
25134  arg1 = static_cast< int >(val1);
25135  ecode2 = SWIG_AsVal_int(obj1, &val2);
25136  if (!SWIG_IsOK(ecode2)) {
25137  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PairIntInt" "', argument " "2"" of type '" "int""'");
25138  }
25139  arg2 = static_cast< int >(val2);
25140  result = (std::pair< int,int > *)new std::pair< int,int >(arg1,arg2);
25141  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_int_t, SWIG_POINTER_NEW | 0 );
25142  return resultobj;
25143 fail:
25144  return NULL;
25145 }
25146 
25147 
25148 SWIGINTERN PyObject *_wrap_new_PairIntInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25149  PyObject *resultobj = 0;
25150  std::pair< int,int > *arg1 = 0 ;
25151  int res1 = SWIG_OLDOBJ ;
25152  PyObject * obj0 = 0 ;
25153  std::pair< int,int > *result = 0 ;
25154 
25155  if (!PyArg_ParseTuple(args,(char *)"O:new_PairIntInt",&obj0)) SWIG_fail;
25156  {
25157  std::pair< int,int > *ptr = (std::pair< int,int > *)0;
25158  res1 = swig::asptr(obj0, &ptr);
25159  if (!SWIG_IsOK(res1)) {
25160  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PairIntInt" "', argument " "1"" of type '" "std::pair< int,int > const &""'");
25161  }
25162  if (!ptr) {
25163  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PairIntInt" "', argument " "1"" of type '" "std::pair< int,int > const &""'");
25164  }
25165  arg1 = ptr;
25166  }
25167  result = (std::pair< int,int > *)new std::pair< int,int >((std::pair< int,int > const &)*arg1);
25168  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_int_t, SWIG_POINTER_NEW | 0 );
25169  if (SWIG_IsNewObj(res1)) delete arg1;
25170  return resultobj;
25171 fail:
25172  if (SWIG_IsNewObj(res1)) delete arg1;
25173  return NULL;
25174 }
25175 
25176 
25177 SWIGINTERN PyObject *_wrap_new_PairIntInt(PyObject *self, PyObject *args) {
25178  Py_ssize_t argc;
25179  PyObject *argv[3] = {
25180  0
25181  };
25182  Py_ssize_t ii;
25183 
25184  if (!PyTuple_Check(args)) SWIG_fail;
25185  argc = args ? PyObject_Length(args) : 0;
25186  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
25187  argv[ii] = PyTuple_GET_ITEM(args,ii);
25188  }
25189  if (argc == 0) {
25190  return _wrap_new_PairIntInt__SWIG_0(self, args);
25191  }
25192  if (argc == 1) {
25193  int _v;
25194  int res = swig::asptr(argv[0], (std::pair< int,int >**)(0));
25195  _v = SWIG_CheckState(res);
25196  if (_v) {
25197  return _wrap_new_PairIntInt__SWIG_2(self, args);
25198  }
25199  }
25200  if (argc == 2) {
25201  int _v;
25202  {
25203  int res = SWIG_AsVal_int(argv[0], NULL);
25204  _v = SWIG_CheckState(res);
25205  }
25206  if (_v) {
25207  {
25208  int res = SWIG_AsVal_int(argv[1], NULL);
25209  _v = SWIG_CheckState(res);
25210  }
25211  if (_v) {
25212  return _wrap_new_PairIntInt__SWIG_1(self, args);
25213  }
25214  }
25215  }
25216 
25217 fail:
25218  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PairIntInt'.\n"
25219  " Possible C/C++ prototypes are:\n"
25220  " std::pair< int,int >::pair()\n"
25221  " std::pair< int,int >::pair(int,int)\n"
25222  " std::pair< int,int >::pair(std::pair< int,int > const &)\n");
25223  return 0;
25224 }
25225 
25226 
25227 SWIGINTERN PyObject *_wrap_PairIntInt_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25228  PyObject *resultobj = 0;
25229  std::pair< int,int > *arg1 = (std::pair< int,int > *) 0 ;
25230  int arg2 ;
25231  void *argp1 = 0 ;
25232  int res1 = 0 ;
25233  int val2 ;
25234  int ecode2 = 0 ;
25235  PyObject * obj0 = 0 ;
25236  PyObject * obj1 = 0 ;
25237 
25238  if (!PyArg_ParseTuple(args,(char *)"OO:PairIntInt_first_set",&obj0,&obj1)) SWIG_fail;
25239  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__pairT_int_int_t, 0 | 0 );
25240  if (!SWIG_IsOK(res1)) {
25241  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairIntInt_first_set" "', argument " "1"" of type '" "std::pair< int,int > *""'");
25242  }
25243  arg1 = reinterpret_cast< std::pair< int,int > * >(argp1);
25244  ecode2 = SWIG_AsVal_int(obj1, &val2);
25245  if (!SWIG_IsOK(ecode2)) {
25246  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PairIntInt_first_set" "', argument " "2"" of type '" "int""'");
25247  }
25248  arg2 = static_cast< int >(val2);
25249  if (arg1) (arg1)->first = arg2;
25250  resultobj = SWIG_Py_Void();
25251  return resultobj;
25252 fail:
25253  return NULL;
25254 }
25255 
25256 
25257 SWIGINTERN PyObject *_wrap_PairIntInt_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25258  PyObject *resultobj = 0;
25259  std::pair< int,int > *arg1 = (std::pair< int,int > *) 0 ;
25260  void *argp1 = 0 ;
25261  int res1 = 0 ;
25262  PyObject * obj0 = 0 ;
25263  int result;
25264 
25265  if (!PyArg_ParseTuple(args,(char *)"O:PairIntInt_first_get",&obj0)) SWIG_fail;
25266  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__pairT_int_int_t, 0 | 0 );
25267  if (!SWIG_IsOK(res1)) {
25268  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairIntInt_first_get" "', argument " "1"" of type '" "std::pair< int,int > *""'");
25269  }
25270  arg1 = reinterpret_cast< std::pair< int,int > * >(argp1);
25271  result = (int) ((arg1)->first);
25272  resultobj = SWIG_From_int(static_cast< int >(result));
25273  return resultobj;
25274 fail:
25275  return NULL;
25276 }
25277 
25278 
25279 SWIGINTERN PyObject *_wrap_PairIntInt_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25280  PyObject *resultobj = 0;
25281  std::pair< int,int > *arg1 = (std::pair< int,int > *) 0 ;
25282  int arg2 ;
25283  void *argp1 = 0 ;
25284  int res1 = 0 ;
25285  int val2 ;
25286  int ecode2 = 0 ;
25287  PyObject * obj0 = 0 ;
25288  PyObject * obj1 = 0 ;
25289 
25290  if (!PyArg_ParseTuple(args,(char *)"OO:PairIntInt_second_set",&obj0,&obj1)) SWIG_fail;
25291  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__pairT_int_int_t, 0 | 0 );
25292  if (!SWIG_IsOK(res1)) {
25293  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairIntInt_second_set" "', argument " "1"" of type '" "std::pair< int,int > *""'");
25294  }
25295  arg1 = reinterpret_cast< std::pair< int,int > * >(argp1);
25296  ecode2 = SWIG_AsVal_int(obj1, &val2);
25297  if (!SWIG_IsOK(ecode2)) {
25298  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PairIntInt_second_set" "', argument " "2"" of type '" "int""'");
25299  }
25300  arg2 = static_cast< int >(val2);
25301  if (arg1) (arg1)->second = arg2;
25302  resultobj = SWIG_Py_Void();
25303  return resultobj;
25304 fail:
25305  return NULL;
25306 }
25307 
25308 
25309 SWIGINTERN PyObject *_wrap_PairIntInt_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25310  PyObject *resultobj = 0;
25311  std::pair< int,int > *arg1 = (std::pair< int,int > *) 0 ;
25312  void *argp1 = 0 ;
25313  int res1 = 0 ;
25314  PyObject * obj0 = 0 ;
25315  int result;
25316 
25317  if (!PyArg_ParseTuple(args,(char *)"O:PairIntInt_second_get",&obj0)) SWIG_fail;
25318  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__pairT_int_int_t, 0 | 0 );
25319  if (!SWIG_IsOK(res1)) {
25320  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairIntInt_second_get" "', argument " "1"" of type '" "std::pair< int,int > *""'");
25321  }
25322  arg1 = reinterpret_cast< std::pair< int,int > * >(argp1);
25323  result = (int) ((arg1)->second);
25324  resultobj = SWIG_From_int(static_cast< int >(result));
25325  return resultobj;
25326 fail:
25327  return NULL;
25328 }
25329 
25330 
25331 SWIGINTERN PyObject *_wrap_delete_PairIntInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25332  PyObject *resultobj = 0;
25333  std::pair< int,int > *arg1 = (std::pair< int,int > *) 0 ;
25334  void *argp1 = 0 ;
25335  int res1 = 0 ;
25336  PyObject * obj0 = 0 ;
25337 
25338  if (!PyArg_ParseTuple(args,(char *)"O:delete_PairIntInt",&obj0)) SWIG_fail;
25339  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__pairT_int_int_t, SWIG_POINTER_DISOWN | 0 );
25340  if (!SWIG_IsOK(res1)) {
25341  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PairIntInt" "', argument " "1"" of type '" "std::pair< int,int > *""'");
25342  }
25343  arg1 = reinterpret_cast< std::pair< int,int > * >(argp1);
25344  delete arg1;
25345  resultobj = SWIG_Py_Void();
25346  return resultobj;
25347 fail:
25348  return NULL;
25349 }
25350 
25351 
25352 SWIGINTERN PyObject *PairIntInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25353  PyObject *obj;
25354  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
25355  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_int_int_t, SWIG_NewClientData(obj));
25356  return SWIG_Py_Void();
25357 }
25358 
25359 SWIGINTERN PyObject *_wrap_new_MapIntInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25360  PyObject *resultobj = 0;
25361  std::less< int > *arg1 = 0 ;
25362  void *argp1 = 0 ;
25363  int res1 = 0 ;
25364  PyObject * obj0 = 0 ;
25365  std::map< int,int > *result = 0 ;
25366 
25367  if (!PyArg_ParseTuple(args,(char *)"O:new_MapIntInt",&obj0)) SWIG_fail;
25368  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_int_t, 0 | 0);
25369  if (!SWIG_IsOK(res1)) {
25370  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapIntInt" "', argument " "1"" of type '" "std::less< int > const &""'");
25371  }
25372  if (!argp1) {
25373  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapIntInt" "', argument " "1"" of type '" "std::less< int > const &""'");
25374  }
25375  arg1 = reinterpret_cast< std::less< int > * >(argp1);
25376  result = (std::map< int,int > *)new std::map< int,int >((std::less< int > const &)*arg1);
25377  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, SWIG_POINTER_NEW | 0 );
25378  return resultobj;
25379 fail:
25380  return NULL;
25381 }
25382 
25383 
25384 SWIGINTERN PyObject *_wrap_MapIntInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25385  PyObject *resultobj = 0;
25386  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25387  PyObject **arg2 = (PyObject **) 0 ;
25388  void *argp1 = 0 ;
25389  int res1 = 0 ;
25390  PyObject * obj0 = 0 ;
25391  swig::SwigPyIterator *result = 0 ;
25392 
25393  arg2 = &obj0;
25394  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_iterator",&obj0)) SWIG_fail;
25395  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25396  if (!SWIG_IsOK(res1)) {
25397  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_iterator" "', argument " "1"" of type '" "std::map< int,int > *""'");
25398  }
25399  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25400  result = (swig::SwigPyIterator *)std_map_Sl_int_Sc_int_Sg__iterator(arg1,arg2);
25401  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
25402  return resultobj;
25403 fail:
25404  return NULL;
25405 }
25406 
25407 
25408 SWIGINTERN PyObject *_wrap_MapIntInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25409  PyObject *resultobj = 0;
25410  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25411  void *argp1 = 0 ;
25412  int res1 = 0 ;
25413  PyObject * obj0 = 0 ;
25414  bool result;
25415 
25416  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt___nonzero__",&obj0)) SWIG_fail;
25417  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25418  if (!SWIG_IsOK(res1)) {
25419  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___nonzero__" "', argument " "1"" of type '" "std::map< int,int > const *""'");
25420  }
25421  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25422  result = (bool)std_map_Sl_int_Sc_int_Sg____nonzero__((std::map< int,int > const *)arg1);
25423  resultobj = SWIG_From_bool(static_cast< bool >(result));
25424  return resultobj;
25425 fail:
25426  return NULL;
25427 }
25428 
25429 
25430 SWIGINTERN PyObject *_wrap_MapIntInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25431  PyObject *resultobj = 0;
25432  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25433  void *argp1 = 0 ;
25434  int res1 = 0 ;
25435  PyObject * obj0 = 0 ;
25436  bool result;
25437 
25438  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt___bool__",&obj0)) SWIG_fail;
25439  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25440  if (!SWIG_IsOK(res1)) {
25441  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___bool__" "', argument " "1"" of type '" "std::map< int,int > const *""'");
25442  }
25443  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25444  result = (bool)std_map_Sl_int_Sc_int_Sg____bool__((std::map< int,int > const *)arg1);
25445  resultobj = SWIG_From_bool(static_cast< bool >(result));
25446  return resultobj;
25447 fail:
25448  return NULL;
25449 }
25450 
25451 
25452 SWIGINTERN PyObject *_wrap_MapIntInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25453  PyObject *resultobj = 0;
25454  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25455  void *argp1 = 0 ;
25456  int res1 = 0 ;
25457  PyObject * obj0 = 0 ;
25458  std::map< int,int >::size_type result;
25459 
25460  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt___len__",&obj0)) SWIG_fail;
25461  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25462  if (!SWIG_IsOK(res1)) {
25463  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___len__" "', argument " "1"" of type '" "std::map< int,int > const *""'");
25464  }
25465  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25466  result = std_map_Sl_int_Sc_int_Sg____len__((std::map< int,int > const *)arg1);
25467  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
25468  return resultobj;
25469 fail:
25470  return NULL;
25471 }
25472 
25473 
25474 SWIGINTERN PyObject *_wrap_MapIntInt___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25475  PyObject *resultobj = 0;
25476  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25477  std::map< int,int >::key_type *arg2 = 0 ;
25478  void *argp1 = 0 ;
25479  int res1 = 0 ;
25480  std::map< int,int >::key_type temp2 ;
25481  int val2 ;
25482  int ecode2 = 0 ;
25483  PyObject * obj0 = 0 ;
25484  PyObject * obj1 = 0 ;
25485  std::map< int,int >::mapped_type *result = 0 ;
25486 
25487  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt___getitem__",&obj0,&obj1)) SWIG_fail;
25488  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25489  if (!SWIG_IsOK(res1)) {
25490  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___getitem__" "', argument " "1"" of type '" "std::map< int,int > *""'");
25491  }
25492  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25493  ecode2 = SWIG_AsVal_int(obj1, &val2);
25494  if (!SWIG_IsOK(ecode2)) {
25495  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt___getitem__" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
25496  }
25497  temp2 = static_cast< std::map< int,int >::key_type >(val2);
25498  arg2 = &temp2;
25499  try {
25500  result = (std::map< int,int >::mapped_type *) &std_map_Sl_int_Sc_int_Sg____getitem__(arg1,(int const &)*arg2);
25501  }
25502  catch(std::out_of_range &_e) {
25503  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
25504  }
25505 
25506  resultobj = SWIG_From_int(static_cast< int >(*result));
25507  return resultobj;
25508 fail:
25509  return NULL;
25510 }
25511 
25512 
25513 SWIGINTERN PyObject *_wrap_MapIntInt___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25514  PyObject *resultobj = 0;
25515  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25516  std::map< int,int >::key_type *arg2 = 0 ;
25517  void *argp1 = 0 ;
25518  int res1 = 0 ;
25519  std::map< int,int >::key_type temp2 ;
25520  int val2 ;
25521  int ecode2 = 0 ;
25522  PyObject * obj0 = 0 ;
25523  PyObject * obj1 = 0 ;
25524 
25525  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt___delitem__",&obj0,&obj1)) SWIG_fail;
25526  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25527  if (!SWIG_IsOK(res1)) {
25528  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___delitem__" "', argument " "1"" of type '" "std::map< int,int > *""'");
25529  }
25530  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25531  ecode2 = SWIG_AsVal_int(obj1, &val2);
25532  if (!SWIG_IsOK(ecode2)) {
25533  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt___delitem__" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
25534  }
25535  temp2 = static_cast< std::map< int,int >::key_type >(val2);
25536  arg2 = &temp2;
25537  try {
25538  std_map_Sl_int_Sc_int_Sg____delitem__(arg1,(int const &)*arg2);
25539  }
25540  catch(std::out_of_range &_e) {
25541  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
25542  }
25543 
25544  resultobj = SWIG_Py_Void();
25545  return resultobj;
25546 fail:
25547  return NULL;
25548 }
25549 
25550 
25551 SWIGINTERN PyObject *_wrap_MapIntInt_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25552  PyObject *resultobj = 0;
25553  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25554  std::map< int,int >::key_type *arg2 = 0 ;
25555  void *argp1 = 0 ;
25556  int res1 = 0 ;
25557  std::map< int,int >::key_type temp2 ;
25558  int val2 ;
25559  int ecode2 = 0 ;
25560  PyObject * obj0 = 0 ;
25561  PyObject * obj1 = 0 ;
25562  bool result;
25563 
25564  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_has_key",&obj0,&obj1)) SWIG_fail;
25565  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25566  if (!SWIG_IsOK(res1)) {
25567  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_has_key" "', argument " "1"" of type '" "std::map< int,int > const *""'");
25568  }
25569  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25570  ecode2 = SWIG_AsVal_int(obj1, &val2);
25571  if (!SWIG_IsOK(ecode2)) {
25572  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_has_key" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
25573  }
25574  temp2 = static_cast< std::map< int,int >::key_type >(val2);
25575  arg2 = &temp2;
25576  result = (bool)std_map_Sl_int_Sc_int_Sg__has_key((std::map< int,int > const *)arg1,(int const &)*arg2);
25577  resultobj = SWIG_From_bool(static_cast< bool >(result));
25578  return resultobj;
25579 fail:
25580  return NULL;
25581 }
25582 
25583 
25584 SWIGINTERN PyObject *_wrap_MapIntInt_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25585  PyObject *resultobj = 0;
25586  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25587  void *argp1 = 0 ;
25588  int res1 = 0 ;
25589  PyObject * obj0 = 0 ;
25590  PyObject *result = 0 ;
25591 
25592  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_keys",&obj0)) SWIG_fail;
25593  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25594  if (!SWIG_IsOK(res1)) {
25595  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_keys" "', argument " "1"" of type '" "std::map< int,int > *""'");
25596  }
25597  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25598  result = (PyObject *)std_map_Sl_int_Sc_int_Sg__keys(arg1);
25599  resultobj = result;
25600  return resultobj;
25601 fail:
25602  return NULL;
25603 }
25604 
25605 
25606 SWIGINTERN PyObject *_wrap_MapIntInt_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25607  PyObject *resultobj = 0;
25608  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25609  void *argp1 = 0 ;
25610  int res1 = 0 ;
25611  PyObject * obj0 = 0 ;
25612  PyObject *result = 0 ;
25613 
25614  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_values",&obj0)) SWIG_fail;
25615  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25616  if (!SWIG_IsOK(res1)) {
25617  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_values" "', argument " "1"" of type '" "std::map< int,int > *""'");
25618  }
25619  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25620  result = (PyObject *)std_map_Sl_int_Sc_int_Sg__values(arg1);
25621  resultobj = result;
25622  return resultobj;
25623 fail:
25624  return NULL;
25625 }
25626 
25627 
25628 SWIGINTERN PyObject *_wrap_MapIntInt_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25629  PyObject *resultobj = 0;
25630  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25631  void *argp1 = 0 ;
25632  int res1 = 0 ;
25633  PyObject * obj0 = 0 ;
25634  PyObject *result = 0 ;
25635 
25636  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_items",&obj0)) SWIG_fail;
25637  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25638  if (!SWIG_IsOK(res1)) {
25639  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_items" "', argument " "1"" of type '" "std::map< int,int > *""'");
25640  }
25641  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25642  result = (PyObject *)std_map_Sl_int_Sc_int_Sg__items(arg1);
25643  resultobj = result;
25644  return resultobj;
25645 fail:
25646  return NULL;
25647 }
25648 
25649 
25650 SWIGINTERN PyObject *_wrap_MapIntInt___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25651  PyObject *resultobj = 0;
25652  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25653  std::map< int,int >::key_type *arg2 = 0 ;
25654  void *argp1 = 0 ;
25655  int res1 = 0 ;
25656  std::map< int,int >::key_type temp2 ;
25657  int val2 ;
25658  int ecode2 = 0 ;
25659  PyObject * obj0 = 0 ;
25660  PyObject * obj1 = 0 ;
25661  bool result;
25662 
25663  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt___contains__",&obj0,&obj1)) SWIG_fail;
25664  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25665  if (!SWIG_IsOK(res1)) {
25666  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___contains__" "', argument " "1"" of type '" "std::map< int,int > *""'");
25667  }
25668  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25669  ecode2 = SWIG_AsVal_int(obj1, &val2);
25670  if (!SWIG_IsOK(ecode2)) {
25671  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt___contains__" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
25672  }
25673  temp2 = static_cast< std::map< int,int >::key_type >(val2);
25674  arg2 = &temp2;
25675  result = (bool)std_map_Sl_int_Sc_int_Sg____contains__(arg1,(int const &)*arg2);
25676  resultobj = SWIG_From_bool(static_cast< bool >(result));
25677  return resultobj;
25678 fail:
25679  return NULL;
25680 }
25681 
25682 
25683 SWIGINTERN PyObject *_wrap_MapIntInt_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25684  PyObject *resultobj = 0;
25685  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25686  PyObject **arg2 = (PyObject **) 0 ;
25687  void *argp1 = 0 ;
25688  int res1 = 0 ;
25689  PyObject * obj0 = 0 ;
25690  swig::SwigPyIterator *result = 0 ;
25691 
25692  arg2 = &obj0;
25693  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_key_iterator",&obj0)) SWIG_fail;
25694  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25695  if (!SWIG_IsOK(res1)) {
25696  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_key_iterator" "', argument " "1"" of type '" "std::map< int,int > *""'");
25697  }
25698  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25699  result = (swig::SwigPyIterator *)std_map_Sl_int_Sc_int_Sg__key_iterator(arg1,arg2);
25700  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
25701  return resultobj;
25702 fail:
25703  return NULL;
25704 }
25705 
25706 
25707 SWIGINTERN PyObject *_wrap_MapIntInt_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25708  PyObject *resultobj = 0;
25709  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25710  PyObject **arg2 = (PyObject **) 0 ;
25711  void *argp1 = 0 ;
25712  int res1 = 0 ;
25713  PyObject * obj0 = 0 ;
25714  swig::SwigPyIterator *result = 0 ;
25715 
25716  arg2 = &obj0;
25717  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_value_iterator",&obj0)) SWIG_fail;
25718  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25719  if (!SWIG_IsOK(res1)) {
25720  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_value_iterator" "', argument " "1"" of type '" "std::map< int,int > *""'");
25721  }
25722  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25723  result = (swig::SwigPyIterator *)std_map_Sl_int_Sc_int_Sg__value_iterator(arg1,arg2);
25724  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
25725  return resultobj;
25726 fail:
25727  return NULL;
25728 }
25729 
25730 
25731 SWIGINTERN PyObject *_wrap_MapIntInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25732  PyObject *resultobj = 0;
25733  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25734  std::map< int,int >::key_type *arg2 = 0 ;
25735  void *argp1 = 0 ;
25736  int res1 = 0 ;
25737  std::map< int,int >::key_type temp2 ;
25738  int val2 ;
25739  int ecode2 = 0 ;
25740  PyObject * obj0 = 0 ;
25741  PyObject * obj1 = 0 ;
25742 
25743  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt___setitem__",&obj0,&obj1)) SWIG_fail;
25744  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25745  if (!SWIG_IsOK(res1)) {
25746  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___setitem__" "', argument " "1"" of type '" "std::map< int,int > *""'");
25747  }
25748  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25749  ecode2 = SWIG_AsVal_int(obj1, &val2);
25750  if (!SWIG_IsOK(ecode2)) {
25751  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt___setitem__" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
25752  }
25753  temp2 = static_cast< std::map< int,int >::key_type >(val2);
25754  arg2 = &temp2;
25755  std_map_Sl_int_Sc_int_Sg____setitem____SWIG_0(arg1,(int const &)*arg2);
25756  resultobj = SWIG_Py_Void();
25757  return resultobj;
25758 fail:
25759  return NULL;
25760 }
25761 
25762 
25763 SWIGINTERN PyObject *_wrap_MapIntInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25764  PyObject *resultobj = 0;
25765  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25766  std::map< int,int >::key_type *arg2 = 0 ;
25767  std::map< int,int >::mapped_type *arg3 = 0 ;
25768  void *argp1 = 0 ;
25769  int res1 = 0 ;
25770  std::map< int,int >::key_type temp2 ;
25771  int val2 ;
25772  int ecode2 = 0 ;
25773  std::map< int,int >::mapped_type temp3 ;
25774  int val3 ;
25775  int ecode3 = 0 ;
25776  PyObject * obj0 = 0 ;
25777  PyObject * obj1 = 0 ;
25778  PyObject * obj2 = 0 ;
25779 
25780  if (!PyArg_ParseTuple(args,(char *)"OOO:MapIntInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
25781  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25782  if (!SWIG_IsOK(res1)) {
25783  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___setitem__" "', argument " "1"" of type '" "std::map< int,int > *""'");
25784  }
25785  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25786  ecode2 = SWIG_AsVal_int(obj1, &val2);
25787  if (!SWIG_IsOK(ecode2)) {
25788  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt___setitem__" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
25789  }
25790  temp2 = static_cast< std::map< int,int >::key_type >(val2);
25791  arg2 = &temp2;
25792  ecode3 = SWIG_AsVal_int(obj2, &val3);
25793  if (!SWIG_IsOK(ecode3)) {
25794  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MapIntInt___setitem__" "', argument " "3"" of type '" "std::map< int,int >::mapped_type""'");
25795  }
25796  temp3 = static_cast< std::map< int,int >::mapped_type >(val3);
25797  arg3 = &temp3;
25798  try {
25799  std_map_Sl_int_Sc_int_Sg____setitem____SWIG_1(arg1,(int const &)*arg2,(int const &)*arg3);
25800  }
25801  catch(std::out_of_range &_e) {
25802  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
25803  }
25804 
25805  resultobj = SWIG_Py_Void();
25806  return resultobj;
25807 fail:
25808  return NULL;
25809 }
25810 
25811 
25812 SWIGINTERN PyObject *_wrap_MapIntInt___setitem__(PyObject *self, PyObject *args) {
25813  Py_ssize_t argc;
25814  PyObject *argv[4] = {
25815  0
25816  };
25817  Py_ssize_t ii;
25818 
25819  if (!PyTuple_Check(args)) SWIG_fail;
25820  argc = args ? PyObject_Length(args) : 0;
25821  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
25822  argv[ii] = PyTuple_GET_ITEM(args,ii);
25823  }
25824  if (argc == 2) {
25825  int _v;
25826  int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
25827  _v = SWIG_CheckState(res);
25828  if (_v) {
25829  {
25830  int res = SWIG_AsVal_int(argv[1], NULL);
25831  _v = SWIG_CheckState(res);
25832  }
25833  if (_v) {
25834  return _wrap_MapIntInt___setitem____SWIG_0(self, args);
25835  }
25836  }
25837  }
25838  if (argc == 3) {
25839  int _v;
25840  int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
25841  _v = SWIG_CheckState(res);
25842  if (_v) {
25843  {
25844  int res = SWIG_AsVal_int(argv[1], NULL);
25845  _v = SWIG_CheckState(res);
25846  }
25847  if (_v) {
25848  {
25849  int res = SWIG_AsVal_int(argv[2], NULL);
25850  _v = SWIG_CheckState(res);
25851  }
25852  if (_v) {
25853  return _wrap_MapIntInt___setitem____SWIG_1(self, args);
25854  }
25855  }
25856  }
25857  }
25858 
25859 fail:
25860  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapIntInt___setitem__'.\n"
25861  " Possible C/C++ prototypes are:\n"
25862  " std::map< int,int >::__setitem__(std::map< int,int >::key_type const &)\n"
25863  " std::map< int,int >::__setitem__(std::map< int,int >::key_type const &,std::map< int,int >::mapped_type const &)\n");
25864  return 0;
25865 }
25866 
25867 
25868 SWIGINTERN PyObject *_wrap_MapIntInt_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25869  PyObject *resultobj = 0;
25870  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25871  void *argp1 = 0 ;
25872  int res1 = 0 ;
25873  PyObject * obj0 = 0 ;
25874  PyObject *result = 0 ;
25875 
25876  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_asdict",&obj0)) SWIG_fail;
25877  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25878  if (!SWIG_IsOK(res1)) {
25879  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_asdict" "', argument " "1"" of type '" "std::map< int,int > *""'");
25880  }
25881  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25882  result = (PyObject *)std_map_Sl_int_Sc_int_Sg__asdict(arg1);
25883  resultobj = result;
25884  return resultobj;
25885 fail:
25886  return NULL;
25887 }
25888 
25889 
25890 SWIGINTERN PyObject *_wrap_new_MapIntInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25891  PyObject *resultobj = 0;
25892  std::map< int,int > *result = 0 ;
25893 
25894  if (!PyArg_ParseTuple(args,(char *)":new_MapIntInt")) SWIG_fail;
25895  result = (std::map< int,int > *)new std::map< int,int >();
25896  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, SWIG_POINTER_NEW | 0 );
25897  return resultobj;
25898 fail:
25899  return NULL;
25900 }
25901 
25902 
25903 SWIGINTERN PyObject *_wrap_new_MapIntInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25904  PyObject *resultobj = 0;
25905  std::map< int,int > *arg1 = 0 ;
25906  int res1 = SWIG_OLDOBJ ;
25907  PyObject * obj0 = 0 ;
25908  std::map< int,int > *result = 0 ;
25909 
25910  if (!PyArg_ParseTuple(args,(char *)"O:new_MapIntInt",&obj0)) SWIG_fail;
25911  {
25912  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *ptr = (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *)0;
25913  res1 = swig::asptr(obj0, &ptr);
25914  if (!SWIG_IsOK(res1)) {
25915  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapIntInt" "', argument " "1"" of type '" "std::map< int,int > const &""'");
25916  }
25917  if (!ptr) {
25918  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapIntInt" "', argument " "1"" of type '" "std::map< int,int > const &""'");
25919  }
25920  arg1 = ptr;
25921  }
25922  result = (std::map< int,int > *)new std::map< int,int >((std::map< int,int > const &)*arg1);
25923  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, SWIG_POINTER_NEW | 0 );
25924  if (SWIG_IsNewObj(res1)) delete arg1;
25925  return resultobj;
25926 fail:
25927  if (SWIG_IsNewObj(res1)) delete arg1;
25928  return NULL;
25929 }
25930 
25931 
25932 SWIGINTERN PyObject *_wrap_new_MapIntInt(PyObject *self, PyObject *args) {
25933  Py_ssize_t argc;
25934  PyObject *argv[2] = {
25935  0
25936  };
25937  Py_ssize_t ii;
25938 
25939  if (!PyTuple_Check(args)) SWIG_fail;
25940  argc = args ? PyObject_Length(args) : 0;
25941  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
25942  argv[ii] = PyTuple_GET_ITEM(args,ii);
25943  }
25944  if (argc == 0) {
25945  return _wrap_new_MapIntInt__SWIG_1(self, args);
25946  }
25947  if (argc == 1) {
25948  int _v;
25949  int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_int_t, 0);
25950  _v = SWIG_CheckState(res);
25951  if (_v) {
25952  return _wrap_new_MapIntInt__SWIG_0(self, args);
25953  }
25954  }
25955  if (argc == 1) {
25956  int _v;
25957  int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
25958  _v = SWIG_CheckState(res);
25959  if (_v) {
25960  return _wrap_new_MapIntInt__SWIG_2(self, args);
25961  }
25962  }
25963 
25964 fail:
25965  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapIntInt'.\n"
25966  " Possible C/C++ prototypes are:\n"
25967  " std::map< int,int >::map(std::less< int > const &)\n"
25968  " std::map< int,int >::map()\n"
25969  " std::map< int,int >::map(std::map< int,int > const &)\n");
25970  return 0;
25971 }
25972 
25973 
25974 SWIGINTERN PyObject *_wrap_MapIntInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25975  PyObject *resultobj = 0;
25976  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25977  void *argp1 = 0 ;
25978  int res1 = 0 ;
25979  PyObject * obj0 = 0 ;
25980  bool result;
25981 
25982  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_empty",&obj0)) SWIG_fail;
25983  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
25984  if (!SWIG_IsOK(res1)) {
25985  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_empty" "', argument " "1"" of type '" "std::map< int,int > const *""'");
25986  }
25987  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
25988  result = (bool)((std::map< int,int > const *)arg1)->empty();
25989  resultobj = SWIG_From_bool(static_cast< bool >(result));
25990  return resultobj;
25991 fail:
25992  return NULL;
25993 }
25994 
25995 
25996 SWIGINTERN PyObject *_wrap_MapIntInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25997  PyObject *resultobj = 0;
25998  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
25999  void *argp1 = 0 ;
26000  int res1 = 0 ;
26001  PyObject * obj0 = 0 ;
26002  std::map< int,int >::size_type result;
26003 
26004  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_size",&obj0)) SWIG_fail;
26005  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26006  if (!SWIG_IsOK(res1)) {
26007  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_size" "', argument " "1"" of type '" "std::map< int,int > const *""'");
26008  }
26009  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26010  result = ((std::map< int,int > const *)arg1)->size();
26011  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
26012  return resultobj;
26013 fail:
26014  return NULL;
26015 }
26016 
26017 
26018 SWIGINTERN PyObject *_wrap_MapIntInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26019  PyObject *resultobj = 0;
26020  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26021  std::map< int,int > *arg2 = 0 ;
26022  void *argp1 = 0 ;
26023  int res1 = 0 ;
26024  void *argp2 = 0 ;
26025  int res2 = 0 ;
26026  PyObject * obj0 = 0 ;
26027  PyObject * obj1 = 0 ;
26028 
26029  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_swap",&obj0,&obj1)) SWIG_fail;
26030  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26031  if (!SWIG_IsOK(res1)) {
26032  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_swap" "', argument " "1"" of type '" "std::map< int,int > *""'");
26033  }
26034  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26035  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 );
26036  if (!SWIG_IsOK(res2)) {
26037  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapIntInt_swap" "', argument " "2"" of type '" "std::map< int,int > &""'");
26038  }
26039  if (!argp2) {
26040  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapIntInt_swap" "', argument " "2"" of type '" "std::map< int,int > &""'");
26041  }
26042  arg2 = reinterpret_cast< std::map< int,int > * >(argp2);
26043  (arg1)->swap(*arg2);
26044  resultobj = SWIG_Py_Void();
26045  return resultobj;
26046 fail:
26047  return NULL;
26048 }
26049 
26050 
26051 SWIGINTERN PyObject *_wrap_MapIntInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26052  PyObject *resultobj = 0;
26053  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26054  void *argp1 = 0 ;
26055  int res1 = 0 ;
26056  PyObject * obj0 = 0 ;
26057  std::map< int,int >::iterator result;
26058 
26059  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_begin",&obj0)) SWIG_fail;
26060  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26061  if (!SWIG_IsOK(res1)) {
26062  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_begin" "', argument " "1"" of type '" "std::map< int,int > *""'");
26063  }
26064  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26065  result = (arg1)->begin();
26066  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::iterator & >(result)),
26067  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
26068  return resultobj;
26069 fail:
26070  return NULL;
26071 }
26072 
26073 
26074 SWIGINTERN PyObject *_wrap_MapIntInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26075  PyObject *resultobj = 0;
26076  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26077  void *argp1 = 0 ;
26078  int res1 = 0 ;
26079  PyObject * obj0 = 0 ;
26080  std::map< int,int >::iterator result;
26081 
26082  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_end",&obj0)) SWIG_fail;
26083  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26084  if (!SWIG_IsOK(res1)) {
26085  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_end" "', argument " "1"" of type '" "std::map< int,int > *""'");
26086  }
26087  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26088  result = (arg1)->end();
26089  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::iterator & >(result)),
26090  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
26091  return resultobj;
26092 fail:
26093  return NULL;
26094 }
26095 
26096 
26097 SWIGINTERN PyObject *_wrap_MapIntInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26098  PyObject *resultobj = 0;
26099  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26100  void *argp1 = 0 ;
26101  int res1 = 0 ;
26102  PyObject * obj0 = 0 ;
26103  std::map< int,int >::reverse_iterator result;
26104 
26105  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_rbegin",&obj0)) SWIG_fail;
26106  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26107  if (!SWIG_IsOK(res1)) {
26108  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_rbegin" "', argument " "1"" of type '" "std::map< int,int > *""'");
26109  }
26110  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26111  result = (arg1)->rbegin();
26112  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::reverse_iterator & >(result)),
26113  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
26114  return resultobj;
26115 fail:
26116  return NULL;
26117 }
26118 
26119 
26120 SWIGINTERN PyObject *_wrap_MapIntInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26121  PyObject *resultobj = 0;
26122  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26123  void *argp1 = 0 ;
26124  int res1 = 0 ;
26125  PyObject * obj0 = 0 ;
26126  std::map< int,int >::reverse_iterator result;
26127 
26128  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_rend",&obj0)) SWIG_fail;
26129  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26130  if (!SWIG_IsOK(res1)) {
26131  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_rend" "', argument " "1"" of type '" "std::map< int,int > *""'");
26132  }
26133  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26134  result = (arg1)->rend();
26135  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::reverse_iterator & >(result)),
26136  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
26137  return resultobj;
26138 fail:
26139  return NULL;
26140 }
26141 
26142 
26143 SWIGINTERN PyObject *_wrap_MapIntInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26144  PyObject *resultobj = 0;
26145  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26146  void *argp1 = 0 ;
26147  int res1 = 0 ;
26148  PyObject * obj0 = 0 ;
26149 
26150  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_clear",&obj0)) SWIG_fail;
26151  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26152  if (!SWIG_IsOK(res1)) {
26153  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_clear" "', argument " "1"" of type '" "std::map< int,int > *""'");
26154  }
26155  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26156  (arg1)->clear();
26157  resultobj = SWIG_Py_Void();
26158  return resultobj;
26159 fail:
26160  return NULL;
26161 }
26162 
26163 
26164 SWIGINTERN PyObject *_wrap_MapIntInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26165  PyObject *resultobj = 0;
26166  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26167  void *argp1 = 0 ;
26168  int res1 = 0 ;
26169  PyObject * obj0 = 0 ;
26170  SwigValueWrapper< std::allocator< std::pair< int const,int > > > result;
26171 
26172  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_get_allocator",&obj0)) SWIG_fail;
26173  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26174  if (!SWIG_IsOK(res1)) {
26175  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_get_allocator" "', argument " "1"" of type '" "std::map< int,int > const *""'");
26176  }
26177  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26178  result = ((std::map< int,int > const *)arg1)->get_allocator();
26179  resultobj = SWIG_NewPointerObj((new std::map< int,int >::allocator_type(static_cast< const std::map< int,int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_int_const_int_t_t, SWIG_POINTER_OWN | 0 );
26180  return resultobj;
26181 fail:
26182  return NULL;
26183 }
26184 
26185 
26186 SWIGINTERN PyObject *_wrap_MapIntInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26187  PyObject *resultobj = 0;
26188  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26189  std::map< int,int >::key_type *arg2 = 0 ;
26190  void *argp1 = 0 ;
26191  int res1 = 0 ;
26192  std::map< int,int >::key_type temp2 ;
26193  int val2 ;
26194  int ecode2 = 0 ;
26195  PyObject * obj0 = 0 ;
26196  PyObject * obj1 = 0 ;
26197  std::map< int,int >::size_type result;
26198 
26199  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_erase",&obj0,&obj1)) SWIG_fail;
26200  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26201  if (!SWIG_IsOK(res1)) {
26202  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_erase" "', argument " "1"" of type '" "std::map< int,int > *""'");
26203  }
26204  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26205  ecode2 = SWIG_AsVal_int(obj1, &val2);
26206  if (!SWIG_IsOK(ecode2)) {
26207  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_erase" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
26208  }
26209  temp2 = static_cast< std::map< int,int >::key_type >(val2);
26210  arg2 = &temp2;
26211  result = (arg1)->erase((std::map< int,int >::key_type const &)*arg2);
26212  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
26213  return resultobj;
26214 fail:
26215  return NULL;
26216 }
26217 
26218 
26219 SWIGINTERN PyObject *_wrap_MapIntInt_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26220  PyObject *resultobj = 0;
26221  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26222  std::map< int,int >::key_type *arg2 = 0 ;
26223  void *argp1 = 0 ;
26224  int res1 = 0 ;
26225  std::map< int,int >::key_type temp2 ;
26226  int val2 ;
26227  int ecode2 = 0 ;
26228  PyObject * obj0 = 0 ;
26229  PyObject * obj1 = 0 ;
26230  std::map< int,int >::size_type result;
26231 
26232  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_count",&obj0,&obj1)) SWIG_fail;
26233  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26234  if (!SWIG_IsOK(res1)) {
26235  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_count" "', argument " "1"" of type '" "std::map< int,int > const *""'");
26236  }
26237  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26238  ecode2 = SWIG_AsVal_int(obj1, &val2);
26239  if (!SWIG_IsOK(ecode2)) {
26240  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_count" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
26241  }
26242  temp2 = static_cast< std::map< int,int >::key_type >(val2);
26243  arg2 = &temp2;
26244  result = ((std::map< int,int > const *)arg1)->count((std::map< int,int >::key_type const &)*arg2);
26245  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
26246  return resultobj;
26247 fail:
26248  return NULL;
26249 }
26250 
26251 
26252 SWIGINTERN PyObject *_wrap_MapIntInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26253  PyObject *resultobj = 0;
26254  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26255  std::map< int,int >::iterator arg2 ;
26256  void *argp1 = 0 ;
26257  int res1 = 0 ;
26258  swig::SwigPyIterator *iter2 = 0 ;
26259  int res2 ;
26260  PyObject * obj0 = 0 ;
26261  PyObject * obj1 = 0 ;
26262 
26263  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_erase",&obj0,&obj1)) SWIG_fail;
26264  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26265  if (!SWIG_IsOK(res1)) {
26266  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_erase" "', argument " "1"" of type '" "std::map< int,int > *""'");
26267  }
26268  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26269  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
26270  if (!SWIG_IsOK(res2) || !iter2) {
26271  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "2"" of type '" "std::map< int,int >::iterator""'");
26272  } else {
26274  if (iter_t) {
26275  arg2 = iter_t->get_current();
26276  } else {
26277  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "2"" of type '" "std::map< int,int >::iterator""'");
26278  }
26279  }
26280  std_map_Sl_int_Sc_int_Sg__erase__SWIG_1(arg1,arg2);
26281  resultobj = SWIG_Py_Void();
26282  return resultobj;
26283 fail:
26284  return NULL;
26285 }
26286 
26287 
26288 SWIGINTERN PyObject *_wrap_MapIntInt_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26289  PyObject *resultobj = 0;
26290  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26291  std::map< int,int >::iterator arg2 ;
26292  std::map< int,int >::iterator arg3 ;
26293  void *argp1 = 0 ;
26294  int res1 = 0 ;
26295  swig::SwigPyIterator *iter2 = 0 ;
26296  int res2 ;
26297  swig::SwigPyIterator *iter3 = 0 ;
26298  int res3 ;
26299  PyObject * obj0 = 0 ;
26300  PyObject * obj1 = 0 ;
26301  PyObject * obj2 = 0 ;
26302 
26303  if (!PyArg_ParseTuple(args,(char *)"OOO:MapIntInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
26304  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26305  if (!SWIG_IsOK(res1)) {
26306  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_erase" "', argument " "1"" of type '" "std::map< int,int > *""'");
26307  }
26308  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26309  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
26310  if (!SWIG_IsOK(res2) || !iter2) {
26311  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "2"" of type '" "std::map< int,int >::iterator""'");
26312  } else {
26314  if (iter_t) {
26315  arg2 = iter_t->get_current();
26316  } else {
26317  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "2"" of type '" "std::map< int,int >::iterator""'");
26318  }
26319  }
26320  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
26321  if (!SWIG_IsOK(res3) || !iter3) {
26322  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "3"" of type '" "std::map< int,int >::iterator""'");
26323  } else {
26325  if (iter_t) {
26326  arg3 = iter_t->get_current();
26327  } else {
26328  SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "3"" of type '" "std::map< int,int >::iterator""'");
26329  }
26330  }
26331  std_map_Sl_int_Sc_int_Sg__erase__SWIG_2(arg1,arg2,arg3);
26332  resultobj = SWIG_Py_Void();
26333  return resultobj;
26334 fail:
26335  return NULL;
26336 }
26337 
26338 
26339 SWIGINTERN PyObject *_wrap_MapIntInt_erase(PyObject *self, PyObject *args) {
26340  Py_ssize_t argc;
26341  PyObject *argv[4] = {
26342  0
26343  };
26344  Py_ssize_t ii;
26345 
26346  if (!PyTuple_Check(args)) SWIG_fail;
26347  argc = args ? PyObject_Length(args) : 0;
26348  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
26349  argv[ii] = PyTuple_GET_ITEM(args,ii);
26350  }
26351  if (argc == 2) {
26352  int _v;
26353  int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
26354  _v = SWIG_CheckState(res);
26355  if (_v) {
26356  swig::SwigPyIterator *iter = 0;
26357  int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
26358  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< int,int >::iterator > *>(iter) != 0));
26359  if (_v) {
26360  return _wrap_MapIntInt_erase__SWIG_1(self, args);
26361  }
26362  }
26363  }
26364  if (argc == 2) {
26365  int _v;
26366  int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
26367  _v = SWIG_CheckState(res);
26368  if (_v) {
26369  {
26370  int res = SWIG_AsVal_int(argv[1], NULL);
26371  _v = SWIG_CheckState(res);
26372  }
26373  if (_v) {
26374  return _wrap_MapIntInt_erase__SWIG_0(self, args);
26375  }
26376  }
26377  }
26378  if (argc == 3) {
26379  int _v;
26380  int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
26381  _v = SWIG_CheckState(res);
26382  if (_v) {
26383  swig::SwigPyIterator *iter = 0;
26384  int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
26385  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< int,int >::iterator > *>(iter) != 0));
26386  if (_v) {
26387  swig::SwigPyIterator *iter = 0;
26388  int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
26389  _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< int,int >::iterator > *>(iter) != 0));
26390  if (_v) {
26391  return _wrap_MapIntInt_erase__SWIG_2(self, args);
26392  }
26393  }
26394  }
26395  }
26396 
26397 fail:
26398  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapIntInt_erase'.\n"
26399  " Possible C/C++ prototypes are:\n"
26400  " std::map< int,int >::erase(std::map< int,int >::key_type const &)\n"
26401  " std::map< int,int >::erase(std::map< int,int >::iterator)\n"
26402  " std::map< int,int >::erase(std::map< int,int >::iterator,std::map< int,int >::iterator)\n");
26403  return 0;
26404 }
26405 
26406 
26407 SWIGINTERN PyObject *_wrap_MapIntInt_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26408  PyObject *resultobj = 0;
26409  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26410  std::map< int,int >::key_type *arg2 = 0 ;
26411  void *argp1 = 0 ;
26412  int res1 = 0 ;
26413  std::map< int,int >::key_type temp2 ;
26414  int val2 ;
26415  int ecode2 = 0 ;
26416  PyObject * obj0 = 0 ;
26417  PyObject * obj1 = 0 ;
26418  std::map< int,int >::iterator result;
26419 
26420  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_find",&obj0,&obj1)) SWIG_fail;
26421  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26422  if (!SWIG_IsOK(res1)) {
26423  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_find" "', argument " "1"" of type '" "std::map< int,int > *""'");
26424  }
26425  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26426  ecode2 = SWIG_AsVal_int(obj1, &val2);
26427  if (!SWIG_IsOK(ecode2)) {
26428  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_find" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
26429  }
26430  temp2 = static_cast< std::map< int,int >::key_type >(val2);
26431  arg2 = &temp2;
26432  result = (arg1)->find((std::map< int,int >::key_type const &)*arg2);
26433  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::iterator & >(result)),
26434  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
26435  return resultobj;
26436 fail:
26437  return NULL;
26438 }
26439 
26440 
26441 SWIGINTERN PyObject *_wrap_MapIntInt_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26442  PyObject *resultobj = 0;
26443  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26444  std::map< int,int >::key_type *arg2 = 0 ;
26445  void *argp1 = 0 ;
26446  int res1 = 0 ;
26447  std::map< int,int >::key_type temp2 ;
26448  int val2 ;
26449  int ecode2 = 0 ;
26450  PyObject * obj0 = 0 ;
26451  PyObject * obj1 = 0 ;
26452  std::map< int,int >::iterator result;
26453 
26454  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_lower_bound",&obj0,&obj1)) SWIG_fail;
26455  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26456  if (!SWIG_IsOK(res1)) {
26457  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_lower_bound" "', argument " "1"" of type '" "std::map< int,int > *""'");
26458  }
26459  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26460  ecode2 = SWIG_AsVal_int(obj1, &val2);
26461  if (!SWIG_IsOK(ecode2)) {
26462  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_lower_bound" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
26463  }
26464  temp2 = static_cast< std::map< int,int >::key_type >(val2);
26465  arg2 = &temp2;
26466  result = (arg1)->lower_bound((std::map< int,int >::key_type const &)*arg2);
26467  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::iterator & >(result)),
26468  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
26469  return resultobj;
26470 fail:
26471  return NULL;
26472 }
26473 
26474 
26475 SWIGINTERN PyObject *_wrap_MapIntInt_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26476  PyObject *resultobj = 0;
26477  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26478  std::map< int,int >::key_type *arg2 = 0 ;
26479  void *argp1 = 0 ;
26480  int res1 = 0 ;
26481  std::map< int,int >::key_type temp2 ;
26482  int val2 ;
26483  int ecode2 = 0 ;
26484  PyObject * obj0 = 0 ;
26485  PyObject * obj1 = 0 ;
26486  std::map< int,int >::iterator result;
26487 
26488  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_upper_bound",&obj0,&obj1)) SWIG_fail;
26489  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 | 0 );
26490  if (!SWIG_IsOK(res1)) {
26491  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_upper_bound" "', argument " "1"" of type '" "std::map< int,int > *""'");
26492  }
26493  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26494  ecode2 = SWIG_AsVal_int(obj1, &val2);
26495  if (!SWIG_IsOK(ecode2)) {
26496  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_upper_bound" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
26497  }
26498  temp2 = static_cast< std::map< int,int >::key_type >(val2);
26499  arg2 = &temp2;
26500  result = (arg1)->upper_bound((std::map< int,int >::key_type const &)*arg2);
26501  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::iterator & >(result)),
26502  swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
26503  return resultobj;
26504 fail:
26505  return NULL;
26506 }
26507 
26508 
26509 SWIGINTERN PyObject *_wrap_delete_MapIntInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26510  PyObject *resultobj = 0;
26511  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
26512  void *argp1 = 0 ;
26513  int res1 = 0 ;
26514  PyObject * obj0 = 0 ;
26515 
26516  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapIntInt",&obj0)) SWIG_fail;
26517  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, SWIG_POINTER_DISOWN | 0 );
26518  if (!SWIG_IsOK(res1)) {
26519  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapIntInt" "', argument " "1"" of type '" "std::map< int,int > *""'");
26520  }
26521  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
26522  delete arg1;
26523  resultobj = SWIG_Py_Void();
26524  return resultobj;
26525 fail:
26526  return NULL;
26527 }
26528 
26529 
26530 SWIGINTERN PyObject *MapIntInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26531  PyObject *obj;
26532  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
26533  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, SWIG_NewClientData(obj));
26534  return SWIG_Py_Void();
26535 }
26536 
26537 SWIGINTERN PyObject *_wrap_new_MapStringString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26538  PyObject *resultobj = 0;
26539  std::less< std::string > *arg1 = 0 ;
26540  void *argp1 = 0 ;
26541  int res1 = 0 ;
26542  PyObject * obj0 = 0 ;
26543  std::map< std::string,std::string > *result = 0 ;
26544 
26545  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringString",&obj0)) SWIG_fail;
26546  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_std__string_t, 0 | 0);
26547  if (!SWIG_IsOK(res1)) {
26548  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringString" "', argument " "1"" of type '" "std::less< std::string > const &""'");
26549  }
26550  if (!argp1) {
26551  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringString" "', argument " "1"" of type '" "std::less< std::string > const &""'");
26552  }
26553  arg1 = reinterpret_cast< std::less< std::string > * >(argp1);
26554  result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >((std::less< std::string > const &)*arg1);
26555  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, SWIG_POINTER_NEW | 0 );
26556  return resultobj;
26557 fail:
26558  return NULL;
26559 }
26560 
26561 
26562 SWIGINTERN PyObject *_wrap_MapStringString_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26563  PyObject *resultobj = 0;
26564  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26565  PyObject **arg2 = (PyObject **) 0 ;
26566  void *argp1 = 0 ;
26567  int res1 = 0 ;
26568  PyObject * obj0 = 0 ;
26569  swig::SwigPyIterator *result = 0 ;
26570 
26571  arg2 = &obj0;
26572  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_iterator",&obj0)) SWIG_fail;
26573  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26574  if (!SWIG_IsOK(res1)) {
26575  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_iterator" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26576  }
26577  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26578  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_std_string_Sg__iterator(arg1,arg2);
26579  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
26580  return resultobj;
26581 fail:
26582  return NULL;
26583 }
26584 
26585 
26586 SWIGINTERN PyObject *_wrap_MapStringString___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26587  PyObject *resultobj = 0;
26588  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26589  void *argp1 = 0 ;
26590  int res1 = 0 ;
26591  PyObject * obj0 = 0 ;
26592  bool result;
26593 
26594  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString___nonzero__",&obj0)) SWIG_fail;
26595  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26596  if (!SWIG_IsOK(res1)) {
26597  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___nonzero__" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'");
26598  }
26599  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26600  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg____nonzero__((std::map< std::string,std::string > const *)arg1);
26601  resultobj = SWIG_From_bool(static_cast< bool >(result));
26602  return resultobj;
26603 fail:
26604  return NULL;
26605 }
26606 
26607 
26608 SWIGINTERN PyObject *_wrap_MapStringString___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26609  PyObject *resultobj = 0;
26610  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26611  void *argp1 = 0 ;
26612  int res1 = 0 ;
26613  PyObject * obj0 = 0 ;
26614  bool result;
26615 
26616  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString___bool__",&obj0)) SWIG_fail;
26617  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26618  if (!SWIG_IsOK(res1)) {
26619  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___bool__" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'");
26620  }
26621  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26622  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg____bool__((std::map< std::string,std::string > const *)arg1);
26623  resultobj = SWIG_From_bool(static_cast< bool >(result));
26624  return resultobj;
26625 fail:
26626  return NULL;
26627 }
26628 
26629 
26630 SWIGINTERN PyObject *_wrap_MapStringString___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26631  PyObject *resultobj = 0;
26632  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26633  void *argp1 = 0 ;
26634  int res1 = 0 ;
26635  PyObject * obj0 = 0 ;
26636  std::map< std::string,std::string >::size_type result;
26637 
26638  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString___len__",&obj0)) SWIG_fail;
26639  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26640  if (!SWIG_IsOK(res1)) {
26641  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___len__" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'");
26642  }
26643  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26644  result = std_map_Sl_std_string_Sc_std_string_Sg____len__((std::map< std::string,std::string > const *)arg1);
26645  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
26646  return resultobj;
26647 fail:
26648  return NULL;
26649 }
26650 
26651 
26652 SWIGINTERN PyObject *_wrap_MapStringString___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26653  PyObject *resultobj = 0;
26654  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26655  std::map< std::string,std::string >::key_type *arg2 = 0 ;
26656  void *argp1 = 0 ;
26657  int res1 = 0 ;
26658  int res2 = SWIG_OLDOBJ ;
26659  PyObject * obj0 = 0 ;
26660  PyObject * obj1 = 0 ;
26661  std::map< std::string,std::string >::mapped_type *result = 0 ;
26662 
26663  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString___getitem__",&obj0,&obj1)) SWIG_fail;
26664  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26665  if (!SWIG_IsOK(res1)) {
26666  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___getitem__" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26667  }
26668  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26669  {
26670  std::string *ptr = (std::string *)0;
26671  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
26672  if (!SWIG_IsOK(res2)) {
26673  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString___getitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26674  }
26675  if (!ptr) {
26676  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___getitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26677  }
26678  arg2 = ptr;
26679  }
26680  try {
26681  result = (std::map< std::string,std::string >::mapped_type *) &std_map_Sl_std_string_Sc_std_string_Sg____getitem__(arg1,(std::string const &)*arg2);
26682  }
26683  catch(std::out_of_range &_e) {
26684  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
26685  }
26686 
26687  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
26688  if (SWIG_IsNewObj(res2)) delete arg2;
26689  return resultobj;
26690 fail:
26691  if (SWIG_IsNewObj(res2)) delete arg2;
26692  return NULL;
26693 }
26694 
26695 
26696 SWIGINTERN PyObject *_wrap_MapStringString___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26697  PyObject *resultobj = 0;
26698  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26699  std::map< std::string,std::string >::key_type *arg2 = 0 ;
26700  void *argp1 = 0 ;
26701  int res1 = 0 ;
26702  int res2 = SWIG_OLDOBJ ;
26703  PyObject * obj0 = 0 ;
26704  PyObject * obj1 = 0 ;
26705 
26706  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString___delitem__",&obj0,&obj1)) SWIG_fail;
26707  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26708  if (!SWIG_IsOK(res1)) {
26709  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___delitem__" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26710  }
26711  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26712  {
26713  std::string *ptr = (std::string *)0;
26714  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
26715  if (!SWIG_IsOK(res2)) {
26716  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString___delitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26717  }
26718  if (!ptr) {
26719  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___delitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26720  }
26721  arg2 = ptr;
26722  }
26723  try {
26724  std_map_Sl_std_string_Sc_std_string_Sg____delitem__(arg1,(std::string const &)*arg2);
26725  }
26726  catch(std::out_of_range &_e) {
26727  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
26728  }
26729 
26730  resultobj = SWIG_Py_Void();
26731  if (SWIG_IsNewObj(res2)) delete arg2;
26732  return resultobj;
26733 fail:
26734  if (SWIG_IsNewObj(res2)) delete arg2;
26735  return NULL;
26736 }
26737 
26738 
26739 SWIGINTERN PyObject *_wrap_MapStringString_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26740  PyObject *resultobj = 0;
26741  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26742  std::map< std::string,std::string >::key_type *arg2 = 0 ;
26743  void *argp1 = 0 ;
26744  int res1 = 0 ;
26745  int res2 = SWIG_OLDOBJ ;
26746  PyObject * obj0 = 0 ;
26747  PyObject * obj1 = 0 ;
26748  bool result;
26749 
26750  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString_has_key",&obj0,&obj1)) SWIG_fail;
26751  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26752  if (!SWIG_IsOK(res1)) {
26753  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_has_key" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'");
26754  }
26755  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26756  {
26757  std::string *ptr = (std::string *)0;
26758  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
26759  if (!SWIG_IsOK(res2)) {
26760  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString_has_key" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26761  }
26762  if (!ptr) {
26763  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString_has_key" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26764  }
26765  arg2 = ptr;
26766  }
26767  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__has_key((std::map< std::string,std::string > const *)arg1,(std::string const &)*arg2);
26768  resultobj = SWIG_From_bool(static_cast< bool >(result));
26769  if (SWIG_IsNewObj(res2)) delete arg2;
26770  return resultobj;
26771 fail:
26772  if (SWIG_IsNewObj(res2)) delete arg2;
26773  return NULL;
26774 }
26775 
26776 
26777 SWIGINTERN PyObject *_wrap_MapStringString_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26778  PyObject *resultobj = 0;
26779  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26780  void *argp1 = 0 ;
26781  int res1 = 0 ;
26782  PyObject * obj0 = 0 ;
26783  PyObject *result = 0 ;
26784 
26785  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_keys",&obj0)) SWIG_fail;
26786  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26787  if (!SWIG_IsOK(res1)) {
26788  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_keys" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26789  }
26790  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26791  result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__keys(arg1);
26792  resultobj = result;
26793  return resultobj;
26794 fail:
26795  return NULL;
26796 }
26797 
26798 
26799 SWIGINTERN PyObject *_wrap_MapStringString_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26800  PyObject *resultobj = 0;
26801  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26802  void *argp1 = 0 ;
26803  int res1 = 0 ;
26804  PyObject * obj0 = 0 ;
26805  PyObject *result = 0 ;
26806 
26807  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_values",&obj0)) SWIG_fail;
26808  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26809  if (!SWIG_IsOK(res1)) {
26810  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_values" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26811  }
26812  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26813  result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__values(arg1);
26814  resultobj = result;
26815  return resultobj;
26816 fail:
26817  return NULL;
26818 }
26819 
26820 
26821 SWIGINTERN PyObject *_wrap_MapStringString_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26822  PyObject *resultobj = 0;
26823  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26824  void *argp1 = 0 ;
26825  int res1 = 0 ;
26826  PyObject * obj0 = 0 ;
26827  PyObject *result = 0 ;
26828 
26829  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_items",&obj0)) SWIG_fail;
26830  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26831  if (!SWIG_IsOK(res1)) {
26832  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_items" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26833  }
26834  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26835  result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__items(arg1);
26836  resultobj = result;
26837  return resultobj;
26838 fail:
26839  return NULL;
26840 }
26841 
26842 
26843 SWIGINTERN PyObject *_wrap_MapStringString___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26844  PyObject *resultobj = 0;
26845  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26846  std::map< std::string,std::string >::key_type *arg2 = 0 ;
26847  void *argp1 = 0 ;
26848  int res1 = 0 ;
26849  int res2 = SWIG_OLDOBJ ;
26850  PyObject * obj0 = 0 ;
26851  PyObject * obj1 = 0 ;
26852  bool result;
26853 
26854  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString___contains__",&obj0,&obj1)) SWIG_fail;
26855  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26856  if (!SWIG_IsOK(res1)) {
26857  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___contains__" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26858  }
26859  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26860  {
26861  std::string *ptr = (std::string *)0;
26862  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
26863  if (!SWIG_IsOK(res2)) {
26864  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString___contains__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26865  }
26866  if (!ptr) {
26867  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___contains__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26868  }
26869  arg2 = ptr;
26870  }
26871  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg____contains__(arg1,(std::string const &)*arg2);
26872  resultobj = SWIG_From_bool(static_cast< bool >(result));
26873  if (SWIG_IsNewObj(res2)) delete arg2;
26874  return resultobj;
26875 fail:
26876  if (SWIG_IsNewObj(res2)) delete arg2;
26877  return NULL;
26878 }
26879 
26880 
26881 SWIGINTERN PyObject *_wrap_MapStringString_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26882  PyObject *resultobj = 0;
26883  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26884  PyObject **arg2 = (PyObject **) 0 ;
26885  void *argp1 = 0 ;
26886  int res1 = 0 ;
26887  PyObject * obj0 = 0 ;
26888  swig::SwigPyIterator *result = 0 ;
26889 
26890  arg2 = &obj0;
26891  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_key_iterator",&obj0)) SWIG_fail;
26892  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26893  if (!SWIG_IsOK(res1)) {
26894  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_key_iterator" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26895  }
26896  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26897  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_std_string_Sg__key_iterator(arg1,arg2);
26898  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
26899  return resultobj;
26900 fail:
26901  return NULL;
26902 }
26903 
26904 
26905 SWIGINTERN PyObject *_wrap_MapStringString_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26906  PyObject *resultobj = 0;
26907  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26908  PyObject **arg2 = (PyObject **) 0 ;
26909  void *argp1 = 0 ;
26910  int res1 = 0 ;
26911  PyObject * obj0 = 0 ;
26912  swig::SwigPyIterator *result = 0 ;
26913 
26914  arg2 = &obj0;
26915  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_value_iterator",&obj0)) SWIG_fail;
26916  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26917  if (!SWIG_IsOK(res1)) {
26918  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_value_iterator" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26919  }
26920  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26921  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_std_string_Sg__value_iterator(arg1,arg2);
26922  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
26923  return resultobj;
26924 fail:
26925  return NULL;
26926 }
26927 
26928 
26929 SWIGINTERN PyObject *_wrap_MapStringString___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26930  PyObject *resultobj = 0;
26931  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26932  std::map< std::string,std::string >::key_type *arg2 = 0 ;
26933  void *argp1 = 0 ;
26934  int res1 = 0 ;
26935  int res2 = SWIG_OLDOBJ ;
26936  PyObject * obj0 = 0 ;
26937  PyObject * obj1 = 0 ;
26938 
26939  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString___setitem__",&obj0,&obj1)) SWIG_fail;
26940  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26941  if (!SWIG_IsOK(res1)) {
26942  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___setitem__" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26943  }
26944  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26945  {
26946  std::string *ptr = (std::string *)0;
26947  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
26948  if (!SWIG_IsOK(res2)) {
26949  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString___setitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26950  }
26951  if (!ptr) {
26952  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___setitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26953  }
26954  arg2 = ptr;
26955  }
26956  std_map_Sl_std_string_Sc_std_string_Sg____setitem____SWIG_0(arg1,(std::string const &)*arg2);
26957  resultobj = SWIG_Py_Void();
26958  if (SWIG_IsNewObj(res2)) delete arg2;
26959  return resultobj;
26960 fail:
26961  if (SWIG_IsNewObj(res2)) delete arg2;
26962  return NULL;
26963 }
26964 
26965 
26966 SWIGINTERN PyObject *_wrap_MapStringString___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26967  PyObject *resultobj = 0;
26968  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
26969  std::map< std::string,std::string >::key_type *arg2 = 0 ;
26970  std::map< std::string,std::string >::mapped_type *arg3 = 0 ;
26971  void *argp1 = 0 ;
26972  int res1 = 0 ;
26973  int res2 = SWIG_OLDOBJ ;
26974  int res3 = SWIG_OLDOBJ ;
26975  PyObject * obj0 = 0 ;
26976  PyObject * obj1 = 0 ;
26977  PyObject * obj2 = 0 ;
26978 
26979  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringString___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
26980  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 | 0 );
26981  if (!SWIG_IsOK(res1)) {
26982  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___setitem__" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'");
26983  }
26984  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
26985  {
26986  std::string *ptr = (std::string *)0;
26987  res2 = SWIG_AsPtr_std_string(obj1, &ptr);
26988  if (!SWIG_IsOK(res2)) {
26989  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString___setitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26990  }
26991  if (!ptr) {
26992  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___setitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'");
26993  }
26994  arg2 = ptr;
26995  }
26996  {
26997  std::string *ptr = (std::string *)0;
26998  res3 = SWIG_AsPtr_std_string(obj2, &ptr);
26999  if (!SWIG_IsOK(res3)) {
27000  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MapStringString___setitem__" "', argument " "3"" of type '" "std::map< std::string,std::string >::mapped_type const &""'");
27001  }
27002  if (!ptr) {
27003  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___setitem__" "', argument " "3"" of type '" "std::map< std::string,std::string >::mapped_type const &""'");
27004  }
27005  arg3 = ptr;
27006  }
27007  try {
27008  std_map_Sl_std_string_Sc_std_string_Sg____setitem____SWIG_1(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
27009  }
27010  catch(std::out_of_range &_e) {
27011  SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
27012  }
27013 
27014  resultobj = SWIG_Py_Void();
27015  if (SWIG_IsNewObj(res2)) delete arg2;
27016  if (SWIG_IsNewObj(res3)) delete arg3;
27017  return resultobj;
27018 fail:
27019  if (SWIG_IsNewObj(res2)) delete arg2;
27020  if (SWIG_IsNewObj(res3)) delete arg3;
27021  return NULL;
27022 }
27023 
27024 
27025 SWIGINTERN PyObject *_wrap_MapStringString___setitem__(PyObject *self, PyObject *args) {
27026  Py_ssize_t argc;
27027  PyObject *argv[4] = {
27028  0
27029  };
27030  Py_ssize_t ii;
27031 
27032  if (!PyTuple_Check(args)) SWIG_fail;
27033  argc = args ? PyObject_Length(args) : 0;
27034  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
27035  argv[ii] = PyTuple_GET_ITEM(args,ii);
27036  }
27037  if (argc == 2) {
27038  int _v;
27039  int res = swig::asptr(argv[0], (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >**)(0));
27040  _v = SWIG_CheckState(res);
27041  if (_v) {
27042  int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
27043  _v = SWIG_CheckState(res);
27044  if (_v) {
27045  return _wrap_MapStringString___setitem____SWIG_0(self, args);
27046  }
27047  }
27048  }
27049  if (argc == 3) {
27050  int _v;
27051  int res = swig::asptr(argv[0], (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >**)(0));
27052  _v = SWIG_CheckState(res);
27053  if (_v) {
27054  int res =